> ## 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.

# Microsoft Monetize

> Integrate with Microsoft Monetize (Ad Server) for real-time cohort targeting and campaign insights

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;
      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/pNhz39ducTVcQczh/images/integrations/logos/microsoft.svg?fit=max&auto=format&n=pNhz39ducTVcQczh&q=85&s=9529b6161618c2c2503443b2d35bf484" alt="Microsoft Monetize" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block' }} width="2500" height="2500" data-path="images/integrations/logos/microsoft.svg" />
    </div>

    <h3
      style={{
    margin: 0,
    fontSize: "1.125rem",
    fontWeight: "600",
  }}
    >
      Microsoft Monetize (Ad Server)
    </h3>
  </div>

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

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

        <EnvironmentBadge environment="iOS" />

        <EnvironmentBadge environment="Android" />

        <EnvironmentBadge environment="CTV" />

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

    <BadgeRowCenter label="Capability">
      <BadgeContainer>
        <CapabilityBadge capability="Event Collection" />

        <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",
}}
  >
    Microsoft Monetize (formerly Xandr, AppNexus) is a comprehensive ad serving platform
    that enables publishers to manage and monetize their advertising inventory
    with advanced targeting and reporting capabilities.
  </p>
</Card>

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

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

## Overview

Microsoft Monetize (formerly Xandr, AppNexus) is Microsoft's ad serving platform that provides publishers with tools to manage, deliver, and optimize advertising campaigns. Our integration with Microsoft Monetize enables you to activate Permutive cohorts for real-time targeting and collect comprehensive ad performance data for insights and optimization.

This integration is both a Source and Destination:

* **Source:** Permutive collects ad impression and click events from Microsoft Monetize.
* **Destination:** Permutive activates your cohorts in Microsoft Monetize using targeting key-value pairs.

Use cases include:

* Target your advertising campaigns in real-time with rich Permutive cohorts using Microsoft Monetize's ad server.
* Track ad impressions and clicks in Permutive for insights, retargeting, or modeling.
* **(Advanced) Log-Level Data:** Ingest comprehensive ad event data from Microsoft Monetize Log-Level Data Feeds for enhanced reporting and mobile support.

## Environment Compatibility

| Environment    | Supported    | Notes                                                 |
| -------------- | ------------ | ----------------------------------------------------- |
| **Web**        | <YesBadge /> | Full support with AppNexus Seller Tag                 |
| **iOS**        | <YesBadge /> | Supported via Permutive SDK add-on                    |
| **Android**    | <YesBadge /> | Supported via Permutive SDK add-on                    |
| **CTV**        | <YesBadge /> | Supported via Permutive CTV SDKs                      |
| **API Direct** | <YesBadge /> | For environments where SDK deployment is not possible |

## Prerequisites

* **Member ID** - You must provide your Microsoft Monetize Member ID, which can be found in your [Microsoft Monetize dashboard](https://monetize.xandr.com/).
* **User Credentials** - You must create a Microsoft Monetize user account for Permutive with appropriate permissions. We recommend using an account with the following permissions:
  * View and edit key-values
  * Create and manage targeting keys
  * Access to inventory settings
* **AppNexus Seller Tag** - For Web integration, you must already have the [AppNexus Seller Tag](https://learn.microsoft.com/en-us/xandr/seller-tag/seller-tag) installed on your site and configured to serve your advertising campaigns.

<Expandable title="Advanced: Log-Level Data Feeds">
  #### Log-Level Data Prerequisites

  For comprehensive ad event tracking including mobile support and line item IDs, Permutive can ingest Microsoft Monetize Log-Level Data Feeds.

  * You must have access to Microsoft Monetize's Log-Level Data Feeds feature.
  * You must be able to configure log export to a Permutive-provided GCS bucket.
  * You must provide your Microsoft Monetize Member ID (this must match the member ID writing to the GCS bucket).
</Expandable>

## Setup

<Tabs>
  <Tab title="Primary Setup Steps">
    <Steps>
      <Step title="Enable in Permutive Dashboard">
        You must enable the Microsoft Monetize (Ad Server) integration in the Permutive dashboard. In the Permutive dashboard, navigate to your workspace's integrations page. Click *Add Integration* and select *Microsoft Monetize (Ad Server)*.

        You will be asked to provide:

        * Your Microsoft Monetize Member ID
        * Microsoft Monetize username and password (for API access)
      </Step>

      <Step title="Verify Key-Values in Microsoft Monetize">
        In your Microsoft Monetize dashboard, navigate to *Inventory* => *Key-Values* and search for `permutive`. You should find that a targeting key has been created for *permutive*. If you cannot find the targeting key, please reach out to Permutive Support.
      </Step>

      <Step title="Verify Setup">
        In the Permutive Dashboard, navigate to one of your cohorts. Check that the Microsoft Monetize (Ad Server) activation sync is visible. You can try toggling this to *On*. After doing this, in your Microsoft Monetize dashboard you should see a new targeting value created under the *permutive* targeting key, with the value corresponding to your cohort's ID. This verifies your integration setup is successful.
      </Step>
    </Steps>

    <Expandable title="Advanced: Log-Level Data Feeds">
      ### Log-Level Data Setup

      <Steps>
        <Step title="Enable Log Ingestion in Permutive Dashboard">
          Enable the Microsoft Monetize Log-Level Data integration in your Permutive Dashboard. You will need to specify:

          * Your Microsoft Monetize Member ID
          * Whether to ingest clicks
          * Whether to ingest impressions

          When enabled, Permutive will create a GCS bucket `permutive-xandr-logs-<member_id>` for your log files.
        </Step>

        <Step title="Configure Log Export in Microsoft Monetize">
          In your Microsoft Monetize account, configure your [Log-Level Data Feeds](https://learn.microsoft.com/en-us/xandr/log-level-data/log-level-data-feeds) to export to the Permutive-provided GCS bucket.
        </Step>

        <Step title="Verify Setup">
          Check back after 24 hours. You should see new events (`XandrLogAdImpression` and `XandrLogAdClick`) on the Events page in your Permutive Dashboard with line item IDs included.
        </Step>
      </Steps>

      <Note>
        Log-Level Data integration requires the standard Microsoft Monetize (Ad Server) integration
        (for event collection) to be enabled first.
      </Note>
    </Expandable>
  </Tab>

  <Tab title="Web">
    ### Deploy Microsoft Monetize-specific JavaScript

    You'll need to deploy additional JavaScript on-site, alongside the standard Permutive tag. This script ensures that we are always able to target users with cohort membership data from their previous page views or browsing sessions, and that we collect all ad events even if they occur before Permutive has fully loaded.

    We recommend deploying this script immediately above the Permutive tag:

    ```javascript theme={"dark"}
    window.apntag = window.apntag || {};
    window.apntag.anq = window.apntag.anq || [];
    window.__permutive = window.__permutive || {};
    window.__permutive.appnexusEvents = window.__permutive.appnexusEvents || [];

    [
      "adRequested",
      "adAvailable",
      "adBadRequest",
      "adLoaded",
      "adNoBid",
      "adError",
      "adCollapse",
    ].forEach(function (eventType) {
      window.apntag.anq.push(function () {
        window.apntag.onEvent(eventType, function (arg) {
          window.__permutive.appnexusEvents.push({
            eventType: eventType,
            arg: arg,
          });
        });
      });
    });

    window.apntag.anq.push(function () {
      var original = window.apntag.defineTag;
      window.apntag.defineTag = function (arg) {
        original(arg);
        try {
          if (arg.targetId) {
            var kvs = window.localStorage.getItem("_papns");
            window.apntag.setKeywords(
              arg.targetId,
              { permutive: kvs ? JSON.parse(kvs) : [] },
              { overrideKeyValue: true }
            );
          }
        } catch (e) {
          /* Ignore */
        }
      };
    });
    ```

    <Note>In many cases, this step will have been carried out as part of your initial Permutive deployment.</Note>
  </Tab>

  <Tab title="iOS">
    ### Integrate Permutive with Microsoft Monetize on iOS

    You'll need to integrate the Permutive iOS SDK with your Microsoft Monetize (Xandr) ad requests to enable cohort targeting in-app.

    Permutive offers automatic Xandr ad targeting through a Permutive SDK Add-On library. This add-on provides seamless integration with the Xandr SDK to automatically apply Permutive targeting to your ad requests.

    <Note>
      For complete implementation details and the latest installation instructions, please refer to the [Permutive iOS SDK Xandr Add-On documentation](https://github.com/permutive-engineering/permutive-ios-sdk-xandr-plugin).

      You must have the Permutive iOS SDK installed and configured before adding the Xandr add-on.
    </Note>
  </Tab>

  <Tab title="Android">
    ### Integrate Permutive with Microsoft Monetize on Android

    You'll need to integrate the Permutive Android SDK with your Microsoft Monetize (Xandr) ad requests to enable cohort targeting in-app.

    Alongside our Android SDK, you must add our Xandr/AppNexus add-on dependency to your Gradle build:

    <CodeGroup>
      ```kotlin Kotlin theme={"dark"}
      implementation("com.permutive.android:appnexus:1.7.0")
      ```

      ```groovy Groovy theme={"dark"}
      implementation "com.permutive.android:appnexus:1.7.0"
      ```
    </CodeGroup>

    Our Android SDK then provides methods to automatically add Permutive targeting to your Xandr ads and track impressions:

    <CodeGroup>
      ```kotlin Kotlin theme={"dark"}
      // For AdViews - add Permutive targeting
      banner.addPermutiveTargeting(permutive)
      banner.loadAd()

      // For NativeAdRequests - add Permutive targeting
      nativeAd.addPermutiveTargeting(permutive)

      // For impression tracking - without existing listener
      banner.setPermutiveAdListener(permutive)

      // For impression tracking - with existing listener
      banner.setPermutiveAdListener(
          permutive,
          object : AdListener {
              // ... your listener methods
          }
      )
      ```

      ```java Java theme={"dark"}
      // For AdViews - add Permutive targeting
      banner.addPermutiveTargeting(permutive);
      banner.loadAd();

      // For NativeAdRequests - add Permutive targeting
      nativeAd.addPermutiveTargeting(permutive);

      // For impression tracking
      banner.setPermutiveAdListener(permutive);
      ```
    </CodeGroup>

    <Note>
      If you are already using an `AdListener`, pass it as the optional second parameter to `setPermutiveAdListener` to avoid conflicts with Permutive impression tracking.
    </Note>
  </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 CCS (Custom Cohort Segmentation) API for event tracking and segmentation instead.

    Access to this API requires customer-specific authorization. You will need a dedicated API key from Permutive.

    #### How it Works

    The CCS 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": "user_id",
        "id": "12345"
      },
      "events": [
        {
          "name": "Pageview",
          "time": "2025-10-02T09:40:43.179Z",
          "properties": {}
        }
      ]
    }
    '
    ```

    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.

    For cross-environment segmentation and targeting, the identity provided should be consistent with identities used in your other environments (web, app).

    **Example Response:**

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

    The API response includes cohort IDs for Microsoft Monetize activation under the `appnexus_adserver` key within the `activations` object. These can then be passed to Microsoft Monetize as key-values for targeting.

    **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

With your Microsoft Monetize (Ad Server) integration setup, you'll see the following additional event types collected in Permutive:

<AccordionGroup>
  <Accordion title="AppNexusAdImpression">
    Tracks ad impression events from the AppNexus Seller Tag on web. Based on Microsoft Monetize's ad event callbacks.

    <ResponseField name="auction_id" type="string">
      Unique identifier for the ad auction.
    </ResponseField>

    <ResponseField name="advertiser_id" type="number">
      The Advertiser ID for this impression.
    </ResponseField>

    <ResponseField name="line_item_id" type="number">
      The Line Item ID for this impression (only available with Log-Level Data integration).
    </ResponseField>

    <ResponseField name="campaign_id" type="number">
      The Campaign ID for this impression.
    </ResponseField>

    <ResponseField name="creative_id" type="number">
      The Creative ID for this impression.
    </ResponseField>

    <ResponseField name="tag_id" type="string">
      The ad tag/placement identifier.
    </ResponseField>
  </Accordion>

  <Accordion title="AppNexusAdClick">
    Tracks ad click events from the AppNexus Seller Tag on web.

    <ResponseField name="auction_id" type="string">
      Unique identifier for the ad auction.
    </ResponseField>

    <ResponseField name="advertiser_id" type="number">
      The Advertiser ID for this click.
    </ResponseField>

    <ResponseField name="campaign_id" type="number">
      The Campaign ID for this click.
    </ResponseField>

    <ResponseField name="creative_id" type="number">
      The Creative ID for this click.
    </ResponseField>

    <ResponseField name="tag_id" type="string">
      The ad tag/placement identifier.
    </ResponseField>
  </Accordion>
</AccordionGroup>

<Expandable title="Advanced: Log-Level Data Events">
  ### Log-Level Data Event Types

  <AccordionGroup>
    <Accordion title="XandrLogAdImpression">
      Tracks comprehensive ad impression data from Microsoft Monetize Log-Level Data Feeds. Includes line item IDs and supports mobile platforms.

      <ResponseField name="auction_id" type="string">
        Unique identifier for the ad auction, linking to edge SDK events.
      </ResponseField>

      <ResponseField name="advertiser_id" type="number">
        The Advertiser ID for this impression.
      </ResponseField>

      <ResponseField name="line_item_id" type="number">
        The Line Item ID for this impression, enabling detailed campaign reporting.
      </ResponseField>

      <ResponseField name="campaign_id" type="number">
        The Campaign ID for this impression.
      </ResponseField>

      <ResponseField name="creative_id" type="number">
        The Creative ID for this impression.
      </ResponseField>

      <ResponseField name="member_id" type="number">
        Your Microsoft Monetize Member ID.
      </ResponseField>
    </Accordion>

    <Accordion title="XandrLogAdClick">
      Tracks comprehensive ad click data from Microsoft Monetize Log-Level Data Feeds, including clicks from mobile apps.

      <ResponseField name="auction_id" type="string">
        Unique identifier for the ad auction, linking to edge SDK events.
      </ResponseField>

      <ResponseField name="advertiser_id" type="number">
        The Advertiser ID for this click.
      </ResponseField>

      <ResponseField name="line_item_id" type="number">
        The Line Item ID for this click.
      </ResponseField>

      <ResponseField name="campaign_id" type="number">
        The Campaign ID for this click.
      </ResponseField>

      <ResponseField name="creative_id" type="number">
        The Creative ID for this click.
      </ResponseField>

      <ResponseField name="member_id" type="number">
        Your Microsoft Monetize Member ID.
      </ResponseField>
    </Accordion>
  </AccordionGroup>

  <Note>
    Log-Level Data events are linked to edge SDK events via the `auction_id`
    field, allowing Permutive to enrich log data with user IDs and session
    context.
  </Note>
</Expandable>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Unable to enable Microsoft Monetize (Ad Server) integration in Permutive Dashboard">
    If you see an error when enabling the Microsoft Monetize (Ad Server) integration, check that
    you have provided valid Microsoft Monetize credentials with the correct permissions. The
    user account must have permissions to view and edit key-values and access
    inventory settings. Verify your Member ID is correct.
  </Accordion>

  <Accordion title="The `permutive` targeting key was not created">
    Double check that the Microsoft Monetize user credentials provided to Permutive have the
    correct permissions to create and manage targeting keys. The user must have
    access to the inventory section and permissions to edit key-values. If you
    have reached Microsoft Monetize's limit of targeting keys, you may need to remove an
    old/inactive key first.
  </Accordion>

  <Accordion title="Cohorts not appearing as targeting values in Microsoft Monetize">
    First, verify the cohort is toggled *On* for Microsoft Monetize (Ad Server) activation in
    the Permutive Dashboard. Then check in your Microsoft Monetize dashboard under
    *Inventory* => *Key-Values* that the cohort ID appears as a value under the
    `permutive` targeting key. If the value is missing, try toggling the cohort
    activation off and on again, and contact Permutive Support if the issue
    persists.
  </Accordion>

  <Accordion title="Log-Level Data events not appearing">
    Verify that you have enabled both the standard Microsoft Monetize (Ad Server) integration
    (for event collection) and the Log-Level Data integration. Check that your
    Microsoft Monetize Log-Level Data Feeds are correctly configured to export to the
    Permutive-provided GCS bucket. Allow 24 hours for initial data to appear. If
    events still don't appear, verify your Member ID matches in both the
    dashboard configuration and the service account writing to the GCS bucket.
  </Accordion>

  <Accordion title="Missing line item IDs in events">
    Line item IDs are only available when using the Log-Level Data integration.
    Standard edge SDK events (`AppNexusAdImpression` and `AppNexusAdClick`) do
    not include line item IDs due to limitations of the AppNexus Seller Tag API. To
    get line item IDs, you must enable the Log-Level Data Feeds integration.
  </Accordion>
</AccordionGroup>

## Changelog

### June 2025

* Enhanced support for activating cohorts via Microsoft Monetize (Ad Server) with improved targeting key management

### November 2019

* Initial release of Microsoft Monetize (Ad Server) (formerly Xandr AdServer, AppNexus) integration with cohort activation and event collection

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