> ## Documentation Index
> Fetch the complete documentation index at: https://docs.permutive.com/llms.txt
> Use this file to discover all available pages before exploring further.

# SmartX

> Integrate with SmartX for real-time cohort activation on video advertising.

export const NoBadge = () => {
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.5rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: '#F7D0E2',
    color: '#1A1A1A',
    fontWeight: '500'
  }}>
      No
    </span>;
};

export const YesBadge = () => {
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.5rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: '#C7E8F9',
    color: '#1A1A1A',
    fontWeight: '500'
  }}>
      Yes
    </span>;
};

export const BadgeRowCenter = ({label, children}) => {
  return <div style={{
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'center',
    marginBottom: '0.5rem'
  }}>
      <span style={{
    fontSize: '0.625rem',
    color: '#6b7280',
    textTransform: 'uppercase',
    fontWeight: '500',
    letterSpacing: '0.05em'
  }}>
        {label}
      </span>
      {children}
    </div>;
};

export const BadgeRow = ({label, children}) => {
  return <div style={{
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'flex-start',
    marginBottom: '0.5rem'
  }}>
      <span style={{
    fontSize: '0.625rem',
    color: '#6b7280',
    textTransform: 'uppercase',
    fontWeight: '500',
    letterSpacing: '0.05em'
  }}>
        {label}
      </span>
      {children}
    </div>;
};

export const BadgeContainer = ({children}) => {
  return <div style={{
    display: 'flex',
    gap: '0.25rem',
    flexWrap: 'wrap',
    justifyContent: 'flex-end',
    minWidth: '0',
    flex: '1'
  }}>
      {children}
    </div>;
};

export const ProductRequiredBadge = ({product}) => {
  const getBadgeStyle = product => {
    switch (product) {
      case 'Core Platform':
        return {
          background: '#CB88FC',
          color: '#1A1A1A'
        };
        --purple;
      case 'Routing':
        return {
          background: '#CB88FC',
          color: '#1A1A1A'
        };
        --purple;
      case 'Contextual':
        return {
          background: '#CB88FC',
          color: '#1A1A1A'
        };
        --purple;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(product);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500'
  }}>
      {product}
    </span>;
};

export const SdkRequiredBadge = ({required}) => {
  const getBadgeStyle = required => {
    switch (required) {
      case 'Yes':
        return {
          background: '#C7E8F9',
          color: '#1A1A1A'
        };
        --blue;
      case 'No':
        return {
          background: '#F7D0E2',
          color: '#1A1A1A'
        };
        --pink;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(required);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500'
  }}>
      {required}
    </span>;
};

export const CapabilityBadge = ({capability}) => {
  const getBadgeStyle = capability => {
    switch (capability) {
      case 'Event Collection':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Cohort Activation':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Campaign Optimization':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Identity Signal':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Contextual Signal':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Connectivity':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Routing':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      case 'Data Collaboration':
        return {
          background: '#EFDFC8',
          color: '#1A1A1A'
        };
        --clay;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(capability);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
      {capability}
    </span>;
};

export const EnvironmentBadge = ({environment}) => {
  const getBadgeStyle = environment => {
    switch (environment) {
      case 'Web':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'iOS':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'Android':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'CTV':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'API Direct':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      case 'Realtime API':
        return {
          background: '#F9C1A8',
          color: '#1A1A1A'
        };
        --peach;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(environment);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500',
    whiteSpace: 'nowrap'
  }}>
      {environment}
    </span>;
};

export const DirectionBadge = ({direction}) => {
  const getBadgeStyle = direction => {
    switch (direction) {
      case 'Bidirectional':
        return {
          background: '#FA8784',
          color: '#1A1A1A'
        };
        --tomato;
      case 'Destination':
        return {
          background: '#FA8784',
          color: '#1A1A1A'
        };
        --tomato;
      case 'Source':
        return {
          background: '#FA8784',
          color: '#1A1A1A'
        };
        --tomato;
      default:
        return {
          background: '#A7B3D9',
          color: '#1A1A1A'
        };
        --haze;
    }
  };
  const style = getBadgeStyle(direction);
  return <span style={{
    display: 'inline-block',
    padding: '0.125rem 0.375rem',
    borderRadius: '0.25rem',
    fontSize: '0.625rem',
    background: style.background,
    color: style.color,
    fontWeight: '500'
  }}>
      {direction}
    </span>;
};

<Card title="">
  <div style={{ display: 'flex', alignItems: 'center', marginBottom: '1rem' }}>
    <div style={{ width: '32px', height: '32px', marginRight: '0.75rem', display: 'flex', alignItems: 'center', justifyContent: 'center', flexShrink: 0 }}>
      <img src="https://mintcdn.com/permutive/tHb77nmgR9vFgAxl/images/integrations/logos/smartx.svg?fit=max&auto=format&n=tHb77nmgR9vFgAxl&q=85&s=74c311ba626d446bf3d6882897404e34" alt="SmartX" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block' }} width="26" height="31" data-path="images/integrations/logos/smartx.svg" />
    </div>

    <h3 style={{ margin: 0, fontSize: '1.125rem', fontWeight: '600' }}>SmartX</h3>
  </div>

  <div style={{ marginBottom: '1rem' }}>
    <BadgeRowCenter label="Direction">
      <DirectionBadge direction="Destination" />
    </BadgeRowCenter>

    <BadgeRowCenter label="Environment">
      <BadgeContainer>
        <EnvironmentBadge environment="Web" />

        <EnvironmentBadge environment="iOS" />

        <EnvironmentBadge environment="Android" />

        <EnvironmentBadge environment="CTV" />

        <EnvironmentBadge environment="API Direct" />

        <EnvironmentBadge environment="Realtime API" />
      </BadgeContainer>
    </BadgeRowCenter>

    <BadgeRowCenter label="Capability">
      <BadgeContainer>
        <CapabilityBadge capability="Cohort Activation" />
      </BadgeContainer>
    </BadgeRowCenter>

    <BadgeRowCenter label="SDK Required">
      <SdkRequiredBadge required="Yes" />
    </BadgeRowCenter>

    <BadgeRowCenter label="Product(s) Required">
      <ProductRequiredBadge product="Core Platform" />
    </BadgeRowCenter>
  </div>

  <p style={{ margin: 0, fontSize: '0.875rem', color: '#6b7280', lineHeight: '1.5' }}>
    SmartX is smartclip's ad-serving and programmatic video platform for broadcasters and publishers.
  </p>
</Card>

<CardGroup cols={2}>
  <Card title="Setup" href="#setup" icon="gear" />

  <Card title="Troubleshooting" href="#troubleshooting" icon="wrench" />
</CardGroup>

## Overview

SmartX is smartclip's ad-serving and programmatic video platform, used by broadcasters and publishers to monetize video inventory across web, mobile, and connected TV. The SmartX integration enables real-time activation of Permutive cohorts for campaign targeting within SmartX.

**Key-Value Activation:** Real-time, client-side cohort activation. Cohort IDs are stored in local storage (Web), retrieved via SDK APIs (iOS/Android, including tvOS and Android TV), or returned under the `smartx_keyvalue` activation key by the Realtime API and the Direct API (environments without an SDK), then appended to SmartX ad requests as key-value pairs. Permutive provides the cohort data, and your implementation passes it to SmartX.

## Supported Cohort Types

| Cohort Type        | Supported    | Notes                                                                                                                                     |
| ------------------ | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Custom**         | <YesBadge /> | Computed in real time on the client.                                                                                                      |
| **Lookalike**      | <YesBadge /> | Computed in real time on the client.                                                                                                      |
| **Contextual**     | <YesBadge /> | Delivered through the same key-value; requires contextual script configuration — coordinate with your Permutive Customer Success Manager. |
| **Classification** | <NoBadge />  | In development — not yet supported for key-value integrations.                                                                            |

## Environment Compatibility

| Environment      | Key-Value Activation                                                                                                                                  |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Web**          | <YesBadge />                                                                                                                                          |
| **iOS**          | <YesBadge />                                                                                                                                          |
| **Android**      | <YesBadge />                                                                                                                                          |
| **CTV**          | <YesBadge /> — via the web SDK on TV browsers, the iOS/Android SDKs on tvOS / Android TV / Fire TV, or the Realtime API / API Direct on other devices |
| **API Direct**   | <YesBadge />                                                                                                                                          |
| **Realtime API** | <YesBadge />                                                                                                                                          |

## Prerequisites

* **SmartX Account** - You must have an active SmartX (smartclip) ad server account.
* **Permutive SDK or API Key** - The Permutive SDK must be deployed on the web and app properties where SmartX ad requests are made. For environments without an SDK, use the Realtime API client (public API key) or the Direct API (public API key client-side, private API key server-side).
* **SmartX Coordination** - confirm with SmartX which key-value parameter carries Permutive cohort IDs on ad requests (most likely `permutive`), and whether SmartX must whitelist it for targeting, reporting, and forecasting.

## Setup

<Tabs>
  <Tab title="Primary Setup Steps">
    <Steps>
      <Step title="Enable Integration in Permutive Dashboard">
        Navigate to the integrations page in the Permutive dashboard (Settings → Integrations) and enable the SmartX integration.

        1. Click **Settings** in the navigation menu
        2. Select **Integrations**
        3. Find **SmartX** in the integrations catalog
        4. Click to enable the integration

        Once enabled, you can activate individual cohorts for SmartX via cohort settings or the cohort activations page.
      </Step>

      <Step title="Coordinate with SmartX">
        Confirm the key-value parameter name for Permutive cohorts (most likely `permutive`), and any whitelisting SmartX requires before the values can be used for targeting.
      </Step>

      <Step title="Activate Cohorts">
        In the Permutive dashboard, activate cohorts for SmartX:

        1. Navigate to the cohort you want to activate
        2. Go to cohort settings or the cohort activations page
        3. Enable the SmartX activation for that cohort

        Activated cohort IDs will be made available in the appropriate storage location for each environment.
      </Step>

      <Step title="Implement Cohort Activation Code">
        Follow the environment-specific implementation steps in the tabs (Web, iOS, Android, Realtime API, API Direct) to retrieve cohort IDs and append them to SmartX ad requests.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Web">
    ## Cohort Activation on Web

    When cohorts are activated to SmartX in the Permutive Dashboard, the Permutive SDK stores the cohort IDs in the browser's local storage under the `_psmartx` key. This value is updated in real time as Permutive segments the user on the page.

    **You must implement code to retrieve these cohort IDs from local storage and append them to your SmartX ad requests.** Permutive provides the cohort data, but your implementation is responsible for passing it to SmartX.

    ```javascript theme={"dark"}
    // Retrieve Permutive cohorts from local storage
    var permutiveCohorts;

    try {
      permutiveCohorts = JSON.parse(window.localStorage._psmartx || '[]');
    } catch (e) {
      permutiveCohorts = [];
    }

    // Append the cohort IDs to your SmartX ad request as key-values

    if (permutiveCohorts.length > 0) {
      var cohortsString = permutiveCohorts.join(',');
      // Example: append cohortsString to your SmartX ad request configuration
    }
    ```

    **Important Notes:**

    * The Permutive SDK automatically populates the `_psmartx` local storage field with activated cohort IDs.
    * Ensure the Permutive SDK loads before you attempt to retrieve cohort IDs from local storage.
    * The cohort IDs are updated in real time as users enter or exit cohorts.
    * Coordinate with your development team to integrate this code into your SmartX ad request flow.

    For technical assistance with implementation, contact Permutive Support.
  </Tab>

  <Tab title="iOS">
    ## Cohort Activation on iOS

    Retrieve Permutive cohort IDs for SmartX using the `activations` property:

    ```swift theme={"dark"}
    // Import Permutive SDK
    import Permutive

    // Access SmartX Cohort IDs directly
    let smartXCohorts: [String] = activations["smartx_keyvalue"]

    // Append Permutive cohorts to your SmartX ad request as key-values
    if !smartXCohorts.isEmpty {
        let cohortsString = smartXCohorts.joined(separator: ",")
        // Append cohortsString to your SmartX ad request
    }
    ```

    **Important Notes:**

    * The `activations` property provides direct access to cohort IDs configured for SmartX activation.
    * Use the key `smartx_keyvalue` to retrieve SmartX-specific cohorts.
    * Coordinate with your development team to integrate this code into your SmartX ad request flow.
  </Tab>

  <Tab title="Android">
    ## Cohort Activation on Android

    Retrieve Permutive cohort IDs for SmartX using the `TriggersProvider` API. The callback is invoked whenever cohort membership changes:

    ```kotlin theme={"dark"}
    val triggerAction: TriggerAction = triggersProvider.cohortActivations(
        activationType = "smartx_keyvalue",
        callback = object : Method<List<String>> {
            override fun invoke(cohorts: List<String>) {
                if (cohorts.isNotEmpty()) {
                    // Cohorts available for SmartX activation
                    // Pass these to your SmartX ad requests as key-values
                    println("SmartX cohorts: $cohorts")
                } else {
                    println("No active cohorts with a SmartX activation configured.")
                }
            }
        }
    )
    ```

    Once you have the cohort IDs, append them to your SmartX ad request as key-values.

    **Important Notes:**

    * The `TriggersProvider` API allows you to listen for cohort membership changes.
    * Use the activation type `smartx_keyvalue` to retrieve SmartX-specific cohorts.
    * See the [Android SDK documentation](https://sdk-docs.permutive.com/core/com.permutive.android/-triggers-provider/query-reactions.html) for more details.
  </Tab>

  <Tab title="Realtime API">
    ## Cohort Activation via the Realtime API

    In environments where the Permutive web or mobile SDKs are not deployed (for
    example, CTV applications), use the Permutive Realtime API client. The client
    keeps a live copy of the user's cohort memberships in sync as the server
    recomputes them, and exposes the cohorts activated for each platform — ready
    to place into your SmartX ad request.

    No SmartX-specific client configuration is required: once the SmartX
    integration is enabled in the Permutive Dashboard and cohorts are activated
    to it, the Realtime API returns those cohorts under the `smartx_keyvalue`
    activation key.

    Install the client (full usage documentation is on the package pages):

    * [`@permutive-engineering/realtime-api-client`](https://www.npmjs.com/package/@permutive-engineering/realtime-api-client) — plain JavaScript/TypeScript
    * [`@permutive-engineering/realtime-api-client-react`](https://www.npmjs.com/package/@permutive-engineering/realtime-api-client-react) — React bindings

    ### JavaScript

    Read the SmartX activation with `getActivation`, apply it to your ad request,
    and keep it fresh from `onStateChange`:

    ```typescript theme={"dark"}
    import {
      permutive,
      getActivation,
    } from '@permutive-engineering/realtime-api-client'
    import type { SessionState } from '@permutive-engineering/realtime-api-client'

    const client = permutive({ apiKey: 'your-api-key' })

    const session = await client.openSession({
      context: {
        views: { '1': { title: 'Video title', url: 'https://example.com/video' } },
      },
    })

    function applyTargeting(state: SessionState) {
      const cohorts = getActivation(state, 'smartx_keyvalue')
      // Append the cohort IDs to your SmartX ad request as key-values
    }

    applyTargeting(session.getState())
    session.onStateChange(({ current }) => applyTargeting(current))
    ```

    ### React

    The React bindings expose the same activation as a hook. `cohorts` is
    reference-stable, so the effect re-runs only on real changes:

    ```tsx theme={"dark"}
    function SmartXTargeting() {
      const { cohorts, isLoading } = Permutive.useActivation('smartx_keyvalue')
      useEffect(() => {
        if (isLoading) return
        // Append the cohort IDs to your SmartX ad request as key-values
      }, [cohorts, isLoading])
      return null
    }
    ```

    **Important Notes:**

    * The Realtime API client runs client-side and authenticates with your **public** workspace API key (Permutive Dashboard → Settings → Keys).
    * The activated cohort list updates in real time as users enter or exit
      cohorts; re-apply it before each ad request.
    * The activation only returns cohorts whose SmartX activation toggle is set
      to *On* in the Permutive Dashboard.
  </Tab>

  <Tab title="API Direct">
    ## Cohort Activation via API Direct

    In environments where it is not possible to deploy a Permutive SDK, you can use Permutive's Direct API (also known as CCS API: Custom Cohort Segmentation) for event tracking and segmentation instead.

    Access to this API requires customer-specific authorization. Client-side integrations (e.g. calling directly from a CTV app) must use your **public** API key; server-side integrations must use your **private** API key (both found in the Permutive Dashboard → Settings → Keys).

    ### How it Works

    The Direct API can be used to:

    1. Track events for a specific user (optional)
    2. Retrieve cohort IDs for activation

    <Note>
      The `events` array in the request is optional. If you only need to retrieve cohort memberships without tracking a new event, you can pass an empty array.
    </Note>

    **Example Request:**

    ```bash theme={"dark"}
    curl --request POST \
         --url 'https://api.permutive.app/ccs/v1/segmentation?activations=true&synchronous-validation=false&k=PERMUTIVE_API_KEY' \
         --header 'accept: application/json' \
         --header 'content-type: application/json' \
         --data '
    {
      "alias": {
        "tag": "example",
        "id": "12345"
      },
      "events": []
    }
    '
    ```

    The API accepts a user identity passed in the `alias` object. Permutive then either links this identity to an existing Permutive user ID or creates a new Permutive user ID if the identity hasn't been seen before.

    **Example Response:**

    ```json theme={"dark"}
    {
      "user_id": "2008c38f-dece-4570-976d-87593ed001c3",
      "cohorts": ["12345", "23456", "34567"],
      "activations": {
        "smartx_keyvalue": ["12345", "23456"]
      }
    }
    ```

    The API response includes cohort IDs for SmartX activation under the `smartx_keyvalue` key within the `activations` object. These can then be passed to SmartX as key-values on your ad requests.

    **Important Notes:**

    * Replace `PERMUTIVE_API_KEY` with your actual Permutive API key
    * The `activations=true` query parameter is required to receive activation data in the response
  </Tab>
</Tabs>

## Data Types

The SmartX integration is a Destination-only integration for cohort activation. It does not collect event data from SmartX.

<AccordionGroup>
  <Accordion title="Cohort Activation Data (Key-Value)">
    When you activate a cohort to SmartX, Permutive makes the cohort IDs available for targeting via key-value pairs.

    **Cohort ID Format:**

    * On Web, cohort IDs are stored as an array in local storage under the `_psmartx` key.
    * On iOS and Android, cohort IDs are retrieved via the SDK activation APIs using the `smartx_keyvalue` key.
    * Via the Realtime API and the Direct API, cohort IDs are returned under the `smartx_keyvalue` key in the response's `activations` object.
    * Each ID corresponds to a cohort the user is a member of.
    * Custom, lookalike, and contextual cohorts are delivered through the same key.
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Unable to enable SmartX integration in Permutive Dashboard">
    If you cannot see the SmartX integration option in your Permutive Dashboard:

    * Verify with your Permutive Customer Success Manager that the integration is available for your workspace.

    Contact your Permutive Customer Success Manager if the integration is still not visible.
  </Accordion>

  <Accordion title="Cohort IDs not available in local storage">
    If you cannot find cohort IDs in local storage (`_psmartx` key):

    * **Cohort Activation**: Verify the cohort has the SmartX activation toggle set to *On* in the Permutive Dashboard.
    * **SDK Deployment**: Ensure the Permutive SDK is properly deployed and loading on your web pages.
    * **User Membership**: Confirm the current user is actually a member of the activated cohort (check in browser console using `permutive.segments()`).
    * **Browser Console**: Open browser developer tools → Application → Local Storage and check `window.localStorage._psmartx` to see if the key exists.

    If the key exists but is empty, the user may not be in any activated cohorts.
  </Accordion>

  <Accordion title="Cohorts not appearing in SDK APIs (iOS/Android)">
    If cohort IDs are not being returned by the SDK APIs:

    * **Cohort Activation**: Verify the cohort has the SmartX activation toggle set to *On* in the Permutive Dashboard.
    * **SDK Deployment**: Ensure the Permutive SDK is properly deployed and initialized in your app.
    * **Activation Type**: Verify you're using the correct activation type key (`smartx_keyvalue`).
    * **User Membership**: Confirm the current user is a member of the activated cohort.

    For iOS, check the `activations` property. For Android, ensure the `TriggersProvider` callback is properly set up with activation type `smartx_keyvalue`.
  </Accordion>

  <Accordion title="Cohorts not being passed to SmartX ad requests">
    If cohort IDs are available on the client but not appearing in your SmartX ad requests:

    * **Implementation**: Verify you've implemented the code to retrieve cohort IDs (see the Setup tabs for your environment).
    * **Timing**: Ensure the Permutive SDK loads before you attempt to retrieve cohort IDs.
    * **Ad Request Configuration**: Check that your ad request code is correctly appending the cohort values to SmartX ad calls.
    * **Network Inspection**: Use browser developer tools to inspect network requests to SmartX and verify cohort IDs are included.

    For implementation assistance, contact Permutive Support.
  </Accordion>

  <Accordion title="Contextual cohorts not being delivered">
    If contextual cohorts are activated but not appearing in the key-value data:

    * **Contextual Script**: Contextual cohorts require contextual script configuration on your properties. Coordinate with your Permutive Customer Success Manager to confirm it is set up correctly.
    * **Cohort Activation**: Verify the contextual cohort has the SmartX activation toggle set to *On*.
  </Accordion>

  <Accordion title="Realtime API or Direct API returning empty SmartX activations">
    If the `smartx_keyvalue` entry is empty or absent from the `activations` object:

    * **Integration Enabled**: Verify the SmartX integration is enabled in the Permutive Dashboard.
    * **Cohort Activation**: Check that cohorts have the SmartX activation toggle set to *On*.
    * **User Membership**: Ensure the user in the request is a member of an activated cohort (the `cohorts` list in the response shows membership regardless of activation).
    * **Query Parameter (Direct API)**: Confirm the `activations=true` query parameter is included in the request URL.
    * **Propagation Time**: Newly activated cohorts can take some time to appear in API responses after the toggle is switched on — if memberships show in `cohorts` but not under `smartx_keyvalue`, retry after a short wait.
    * **API Key**: Verify the key type matches the integration path (public for client-side, private for server-side Direct API calls) and that your workspace is authorized for the Direct API.

    If the issue persists, contact your Permutive Customer Success Manager.
  </Accordion>

  <Accordion title="Classification cohorts cannot be delivered">
    Classification cohorts are not yet supported for key-value integrations, including SmartX. The activation toggle may be visible in the Permutive Dashboard ahead of this functionality being released.
  </Accordion>
</AccordionGroup>

## Changelog

### September 2026

* Initial release of the SmartX integration for real-time key-value cohort activation (custom, lookalike, and contextual cohorts) on Web, iOS, Android, and CTV, with SDK-less access via the Realtime API and the Direct API

<Info>
  For detailed changelog information, visit our [Changelog](https://changelog.permutive.com/).
</Info>