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

# Prebid

> Integrate with Prebid for targeting and campaign optimization

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/prebid.svg?fit=max&auto=format&n=pNhz39ducTVcQczh&q=85&s=f7b4dcb74c21ec06e0cb6c77ff3bd731" alt="Prebid" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block', backgroundColor: '#f3f4f6', borderRadius: '4px', padding: '2px' }} width="400" height="400" data-path="images/integrations/logos/prebid.svg" />
    </div>

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

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

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

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

        <CapabilityBadge capability="Cohort Activation" />

        <CapabilityBadge capability="Identity Signal" />
      </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",
}}
  >
    Prebid is an open-source header bidding solution that helps publishers
    maximize revenue through real-time bidding.
  </p>
</Card>

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

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

## Overview

Prebid is an open-source header bidding solution that enables publishers to offer their ad inventory to multiple demand sources simultaneously before making calls to their ad servers. Permutive provides two specialized Prebid modules that work independently or together:

1. **Real-Time Data (RTD) Module** - Activates cohort signals in bid requests for audience targeting
2. **Identity Manager Module** - Passes identity signals from third-party identity providers to bidders

This integration is both a Source and Destination:

* **Source:** Permutive collects bid data and auction information from Prebid.js auctions, including bid prices, response times, and winning bids.
* **Destination (Cohort Activation):** Permutive activates your cohorts in Prebid.js auctions for real-time targeting via the RTD module.
* **Destination (Identity Signal Activation):** Permutive passes identity signals (RampID, ID5, UID2) to bidders via the Identity Manager module.

### How It Works

**RTD Module (Cohort Activation):**

The Permutive RTD module acts as a bridge between the Permutive Web SDK and Prebid.js:

1. When users fall into activated cohorts, these are detected by Permutive's Prebid RTD module
2. Cohort data is attached to the `ortb2.user.data` object in bid requests for configured SSPs
3. SSPs receive cohort targeting data and can use it for real-time decisioning

**Identity Manager Module (Identity Signal Activation):**

The Permutive Identity Manager module retrieves identity signals from third-party identity providers and makes them available in Prebid auctions:

1. Identity providers (RampID, ID5, UID2) generate identity envelopes through Permutive's Identity Manager
2. The Permutive Identity Manager module retrieves these identities from the Permutive SDK
3. Identity signals are passed to bidders via the `user.eids` object in bid requests
4. Bidders can decrypt and use these identity signals for targeting and measurement

### Cohort Types

* **Standard Cohorts** (IDs > 1,000,000): Automatically available to all configured AC bidders without specific activation. These are general audience segments.
* **Custom Cohorts**: Must be explicitly activated for each SSP in the Permutive Dashboard. These are your custom-built audience segments.
* **Advertiser Cohorts**: Must be configured by your Customer Success Manager for customers using Permutive's Data Clean Room.

Use cases include:

* Send Permutive cohorts to your Prebid.js auctions for real-time targeting and decisioning across multiple SSPs.
* Pass identity signals (RampID, ID5, UID2) from third-party identity providers to bidders for enhanced addressability and targeting.
* Track bid data and auction performance in Permutive for insights and optimization.
* Build cohorts based on bidder behavior, auction outcomes, and advertiser information.
* Optimize header bidding performance with data-driven audience insights and identity resolution.

## Environment Compatibility

| Environment    | Supported    | Notes                      |
| -------------- | ------------ | -------------------------- |
| **Web**        | <YesBadge /> | Requires Prebid.js v9.5.0+ |
| **iOS**        | <NoBadge />  | Not supported              |
| **Android**    | <NoBadge />  | Not supported              |
| **CTV**        | <NoBadge />  | Not supported              |
| **API Direct** | <NoBadge />  | Not supported              |

## Prerequisites

**For both modules:**

* **Prebid.js Version**: You must have Prebid.js v9.5.0 or later installed on your website.
* **Web SDK**: The Permutive Web SDK must be deployed on your site.
* **GDPR/Consent Management**: If operating in regions with GDPR requirements, you must configure the Prebid consent management module with proper storage exceptions for Permutive.

**For Cohort Activation (RTD Module):**

* **Permutive RTD Module**: The `permutiveRtdProvider` module must be included in your Prebid.js build. This module is essential for reading cohort data from local storage and passing it to SSPs.

**For Identity Signal Activation (Identity Manager Module):**

* **Permutive Identity Manager Module**: The `permutiveIdentityManagerIdSystem` module must be included in your Prebid.js build.
* **Identity Provider Setup**: You must have at least one identity provider (RampID, ID5, or UID2) configured in the Permutive Dashboard. See the [Identity Integration Catalog](/integrations/identity) for details on setting up identity providers.

## Setup

Choose which module(s) you want to configure based on your needs. You can use either module independently or both together.

<Tabs>
  <Tab title="Cohort Activation (RTD Module)">
    <Steps>
      <Step title="Install Prebid.js RTD Module">
        The Permutive Real-Time Data (RTD) module must be included in your Prebid.js build. This module reads cohort data from local storage and passes it to configured SSPs. Ensure your Prebid.js build includes the `permutiveRtdProvider` module.
      </Step>

      <Step title="Configure Prebid.js RTD Module">
        Configure your Prebid.js setup to include the Permutive RTD module. Add the following configuration to your Prebid.js setup:

        ```javascript theme={"dark"}
        pbjs.setConfig({
          realTimeData: {
            auctionDelay: 200, // Milliseconds to delay auction for RTD data
            dataProviders: [{
              name: 'permutive',
              waitForIt: true, // Delays auction until Permutive data is ready
            }]
          }
        });
        ```

        **Configuration Notes:**

        * **`waitForIt: true`**: Ensures the auction waits for the RTD module to complete before sending bid requests. **This is critical** for cohorts to be included in all bid requests.
        * **`auctionDelay`**: Maximum time (in milliseconds) to wait for RTD data. Recommended value is 200-300ms to balance cohort availability with auction speed.
      </Step>

      <Step title="Configure GDPR Consent Management (If Applicable)">
        If you operate in regions with GDPR requirements, you must configure Prebid's consent management to allow Permutive access to local storage. Without this, the RTD module cannot read cohort data.

        As Permutive acts as a processor on behalf of publishers, consent is given to the Permutive SDK by the publisher, not by the GDPR Consent Management Module.

        **Important**: While Permutive is listed as a TCF vendor (ID: 361), Permutive does not obtain consent directly from the TCF. If you are using the TCF Control Module and need to prevent Permutive from being blocked, you must add Permutive as a vendor exception. Here's an example configuration:

        ```javascript theme={"dark"}
        pbjs.setConfig({
          consentManagement: {
            gdpr: {
              cmpApi: 'iab',
              timeout: 8000,
              allowAuctionWithoutConsent: true,
              defaultGdprScope: true,
              rules: [
                {
                  purpose: 'storage',
                  enforcePurpose: true,
                  enforceVendor: true,
                  vendorExceptions: ["permutive"]
                },
                {
                  purpose: 'basicAds',
                  enforcePurpose: true,
                  enforceVendor: true,
                  vendorExceptions: []
                }
              ]
            }
          }
        });
        ```

        Consult the [Prebid consent management documentation](https://docs.prebid.org/dev-docs/modules/consentManagement.html) and [Permutive RTD Provider documentation](https://docs.prebid.org/dev-docs/modules/permutiveRtdProvider.html#context) for detailed guidance.
      </Step>

      <Step title="Verify Setup">
        In the Permutive Dashboard, navigate to your events page. You should start seeing Prebid event data appear. For cohorts with Prebid activation configured, you should see these cohorts available for targeting in your Prebid auctions.

        **To verify cohorts are being passed to SSPs:**

        1. Add `?pbjs_debug=true` to your URL
        2. Open your browser's Developer Console
        3. Filter logs for "permutiveRTD" to see RTD module activity
        4. Look for "Bid requests" logs in Prebid to see cohort data attached to bid requests in the `ortb2.user.data` field
      </Step>
    </Steps>
  </Tab>

  <Tab title="Identity Signal Activation (Identity Manager Module)">
    <Steps>
      <Step title="Configure Identity Providers">
        Before enabling the Prebid Identity Manager module, you must first configure at least one identity provider in the Permutive Dashboard:

        1. Navigate to **Identity** → **Catalog** in your Permutive Dashboard
        2. Select an identity provider (RampID, ID5, or UID2)
        3. Follow the setup instructions for your chosen provider

        For detailed setup instructions, see the individual identity integration documentation:

        * [RampID Integration](/integrations/identity/rampid)
        * [ID5 Integration](/integrations/identity/id5)
        * [UID2 Integration](/integrations/identity/uid2)

        <Info>
          Identity provider configuration (Partner IDs, consent setup, etc.) is handled in the Permutive Dashboard and documented in the individual identity integration guides. The Prebid module configuration below only controls how Prebid retrieves and passes these identities.
        </Info>
      </Step>

      <Step title="Install Prebid.js Identity Manager Module">
        The Permutive Identity Manager module must be included in your Prebid.js build. Ensure your Prebid.js build includes the `permutiveIdentityManagerIdSystem` module.

        If you need to rebuild Prebid with this module, contact your Prebid implementation team or use the [Prebid.js download tool](https://docs.prebid.org/download.html) and select "Permutive Identity Manager" from the User ID Modules list.

        <Info>
          The Permutive Identity Manager module is separate from the Permutive RTD module. Both modules can coexist in the same Prebid setup.
        </Info>
      </Step>

      <Step title="Configure Prebid.js Identity Manager Module">
        Add the following configuration to your Prebid.js setup:

        ```javascript theme={"dark"}
        pbjs.setConfig({
          userSync: {
            userIds: [{
              name: 'permutiveIdentityManagerId',
              params: {
                ajaxTimeout: 90 // Wait up to 90ms for Permutive SDK to become available
              },
              storage: {
                type: 'html5',
                name: 'permutiveIdentityManagerId',
                refreshInSeconds: 5
              }
            }],
            auctionDelay: 100 // Wait for identity signals before starting auction
          }
        });
        ```

        **Configuration Notes:**

        * **`ajaxTimeout`**: Time (in milliseconds) the module will wait for the Permutive SDK to become available. The default is 50ms. Increase this value if your SDK loads slowly.
        * **`auctionDelay`**: Time (in milliseconds) to delay the auction to ensure identity signals are available. Recommended value is 100ms.
        * **`storage`**: Configures how Prebid stores and refreshes identity data. The module reads identity signals from the Permutive SDK's storage.

        For more details, see the [Prebid Identity Manager module documentation](https://docs.prebid.org/dev-docs/modules/userid-submodules/permutiveIdentityManagerIdSystem.html).
      </Step>

      <Step title="Verify Setup">
        To verify that identity signals are being passed to bidders:

        1. Add `?pbjs_debug=true` to your URL
        2. Open your browser's Developer Console
        3. Look for "User ID" logs in Prebid showing the Permutive Identity Manager module
        4. Check bid requests for identity data in the `user.eids` field

        You can also verify in the Permutive Dashboard:

        1. Navigate to **Identity** → **Insights**
        2. Check that identity signals are being generated for your configured providers
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Data Types

With your Prebid integration setup, you'll see the following additional event types collected in Permutive:

<AccordionGroup>
  <Accordion title="PrebidBid">
    Tracks individual bids from Prebid auctions. This event contains detailed information about each bid received during an auction.

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

    <ResponseField name="ad_unit_code" type="string">
      The ad unit code for the slot being auctioned.
    </ResponseField>

    <ResponseField name="bidder" type="string">
      The bidder code (e.g., 'appnexus', 'pubmatic').
    </ResponseField>

    <ResponseField name="cpm" type="number">
      The exact bid price from the bidder in CPM.
    </ResponseField>

    <ResponseField name="width" type="number">
      The width of the returned creative size.
    </ResponseField>

    <ResponseField name="height" type="number">
      The height of the returned creative size.
    </ResponseField>

    <ResponseField name="time_to_respond" type="number">
      The amount of time for the bidder to respond with the bid in milliseconds.
    </ResponseField>

    <ResponseField name="bid_available" type="boolean">
      Boolean indicating whether the bid is available.
    </ResponseField>

    <ResponseField name="winning_bid" type="boolean">
      Boolean indicating whether this bid won the auction.
    </ResponseField>

    <ResponseField name="advertiser_id" type="string">
      The advertiser ID from the bid response.
    </ResponseField>

    <ResponseField name="advertiser_name" type="string">
      The advertiser name from the bid response.
    </ResponseField>

    <ResponseField name="deal_id" type="string">
      If the bid is associated with a Deal, this field contains the deal ID.
    </ResponseField>

    <ResponseField name="creative_id" type="string">
      The ID of the selected creative for the ad.
    </ResponseField>

    <ResponseField name="hb_pb" type="string">
      Prebid bid price bucket.
    </ResponseField>

    <ResponseField name="request_timestamp" type="number">
      The time at which the prebid request was sent.
    </ResponseField>

    <ResponseField name="response_timestamp" type="number">
      The time at which the prebid response was received.
    </ResponseField>
  </Accordion>

  <Accordion title="PrebidWinningBid">
    Tracks winning bids from Prebid auctions. This event is fired when a bid wins an auction and includes all the same properties as PrebidBid.

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

    <ResponseField name="ad_unit_code" type="string">
      The ad unit code for the slot being auctioned.
    </ResponseField>

    <ResponseField name="bidder" type="string">
      The bidder code (e.g., 'appnexus', 'pubmatic').
    </ResponseField>

    <ResponseField name="cpm" type="number">
      The exact bid price from the bidder in CPM.
    </ResponseField>

    <ResponseField name="width" type="number">
      The width of the returned creative size.
    </ResponseField>

    <ResponseField name="height" type="number">
      The height of the returned creative size.
    </ResponseField>

    <ResponseField name="time_to_respond" type="number">
      The amount of time for the bidder to respond with the bid in milliseconds.
    </ResponseField>

    <ResponseField name="bid_available" type="boolean">
      Boolean indicating whether the bid is available.
    </ResponseField>

    <ResponseField name="winning_bid" type="boolean">
      Boolean indicating whether this bid won the auction (always true for this event).
    </ResponseField>

    <ResponseField name="advertiser_id" type="string">
      The advertiser ID from the bid response.
    </ResponseField>

    <ResponseField name="advertiser_name" type="string">
      The advertiser name from the bid response.
    </ResponseField>

    <ResponseField name="deal_id" type="string">
      If the bid is associated with a Deal, this field contains the deal ID.
    </ResponseField>

    <ResponseField name="creative_id" type="string">
      The ID of the selected creative for the ad.
    </ResponseField>

    <ResponseField name="hb_pb" type="string">
      Prebid bid price bucket.
    </ResponseField>

    <ResponseField name="request_timestamp" type="number">
      The time at which the prebid request was sent.
    </ResponseField>

    <ResponseField name="response_timestamp" type="number">
      The time at which the prebid response was received.
    </ResponseField>
  </Accordion>

  <Accordion title="PrebidAuctions">
    Tracks aggregated auction data containing multiple bids and no-bid responses for a single auction. This event provides comprehensive auction-level insights.

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

    <ResponseField name="bids" type="list[object]">
      Array of bid objects containing detailed bid information.
    </ResponseField>

    <ResponseField name="no_bids" type="list[object]">
      Array of no-bid responses from bidders who chose not to bid.
    </ResponseField>

    <ResponseField name="aggregations.auctions" type="list[object]">
      Array of auction objects containing multiple ad units and their associated bids.
    </ResponseField>
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Prebid events not appearing in Permutive Dashboard">
    Check that your Prebid.js version is 9.5.0 or later. Verify that the Permutive RTD module (`permutiveRtdProvider`) is included in your Prebid.js build and properly configured. Ensure the Prebid integration is enabled in your Permutive Dashboard. Use the debugging query parameters `?__permutive.loggingEnabled=true&pbjs_debug=true` in your browser to view detailed logs in the developer console.
  </Accordion>

  <Accordion title="Cohorts not being passed to SSPs">
    **Check local storage first**: Open your browser's Developer Tools, navigate to Application > Local Storage, and verify that cohort data is being written to keys starting with `_P` (e.g., `_prubicons`, `_papns`, `_pindexs`). If these keys are empty, cohorts are not being activated in the Permutive Dashboard. Standard cohorts (IDs over 1,000,000) are automatically available to all AC bidders without specific activation, but custom cohorts must be explicitly activated for each SSP.
  </Accordion>

  <Accordion title="GDPR / Consent Management blocking cohorts">
    If you're seeing warnings about "TCF2 framework" or "activity control"
    denying access in your browser console, your Prebid consent management
    configuration is preventing the RTD module from reading Permutive cohorts.

    **Background**: While Permutive is listed as a TCF vendor (ID: 361), Permutive does not obtain consent directly from the TCF framework. Consent is given to the Permutive SDK by the publisher, not by the GDPR Consent Management Module.

    **Solution**: If using the TCF Control Module, add Permutive as a vendor exception in your consent management configuration. Add the following to your `pbjs.setConfig().consentManagement.gdpr.rules`:

    ```javascript theme={"dark"}
    {
      purpose: 'storage',
      enforcePurpose: true,
      enforceVendor: true,
      vendorExceptions: ["permutive"]
    }
    ```

    Refer to the [Prebid Permutive RTD Provider documentation](https://docs.prebid.org/dev-docs/modules/permutiveRtdProvider.html#context) for detailed guidance.
  </Accordion>

  <Accordion title="RTD module not delaying auction correctly">
    If cohorts are missing from some bid requests, ensure your Real-Time Data configuration includes `waitForIt: true` in the Permutive RTD provider setup. This setting delays the auction until the Permutive RTD module has completed processing. Also verify that `auctionDelay` is set to an appropriate value (typically 200ms or higher) in your `pbjs.setConfig().realTimeData` configuration.
  </Accordion>

  <Accordion title="Prebid version 9.5.0+ upgrade issues">
    If you recently upgraded to Prebid.js v9.5.0 or later and are experiencing issues, this version fixed a critical bug related to how the Permutive RTD module pushes values into ORTB2 objects. If you're on an older version and seeing intermittent targeting issues (especially when numeric targeting values are present), upgrade to v9.5.0 or later. After upgrading, verify that all required modules (RTD module, bid adapter modules, Permutive RTD provider) are still included in your build.
  </Accordion>

  <Accordion title="Multiple Prebid versions causing conflicts">
    Some publishers run multiple versions of Prebid.js on their site (e.g., one for display ads and another for video). This can cause conflicts with the Permutive RTD module. Ensure you're using a single, consistent Prebid.js setup across your site.
  </Accordion>

  <Accordion title="Identity signals not appearing in bid requests">
    If identity signals (RampID, ID5, UID2) are not appearing in the `user.eids` field of bid requests:

    1. **Verify identity provider is enabled**: Navigate to **Identity** → **Catalog** in the Permutive Dashboard and confirm your identity provider is enabled and configured correctly
    2. **Check Prebid module inclusion**: Verify the `permutiveIdentityManagerIdSystem` module is included in your Prebid build by checking your Prebid configuration
    3. **Confirm consent**: Ensure your identity provider has proper consent in your CMP. Each identity provider requires specific TCF purposes to be enabled
    4. **Check SDK timing**: The Identity Manager module needs the Permutive SDK to be available. Increase the `ajaxTimeout` parameter if your SDK loads slowly
    5. **Review debug logs**: Add `?pbjs_debug=true` to your URL and check for "User ID" logs in the console

    For identity provider-specific troubleshooting, see the individual identity integration documentation:

    * [RampID Troubleshooting](/integrations/identity/rampid#troubleshooting)
    * [ID5 Troubleshooting](/integrations/identity/id5#troubleshooting)
    * [UID2 Troubleshooting](/integrations/identity/uid2#troubleshooting)
  </Accordion>

  <Accordion title="Identity Manager module not loading in time">
    If you see empty `user.eids` in some bid requests but not others, the Identity Manager module may not be loading in time for the auction. This can happen if:

    * The Permutive SDK loads slowly on your page
    * The `ajaxTimeout` parameter is too low
    * The `auctionDelay` in userSync configuration is too short

    **Solution**: Increase both the `ajaxTimeout` (in the module params) and `auctionDelay` (in userSync config). Start with `ajaxTimeout: 90` and `auctionDelay: 100`, then adjust based on your page load times.
  </Accordion>

  <Accordion title="Both RTD and Identity Manager modules causing auction delays">
    If you're using both modules and experiencing slow auctions, you may need to optimize your timeout configuration:

    * RTD module `auctionDelay`: Controls how long to wait for cohort data (recommended: 200ms)
    * Identity Manager `auctionDelay`: Controls how long to wait for identity signals (recommended: 100ms)
    * Identity Manager `ajaxTimeout`: Controls how long to wait for the SDK (recommended: 50-90ms)

    **Tip**: The RTD module and Identity Manager module delays are independent. If using both, consider the cumulative impact on auction timing and adjust accordingly to balance data availability with page performance.
  </Accordion>

  <Accordion title="Debugging with query parameters">
    To troubleshoot Prebid integration issues, add these query parameters to your URL: `?__permutive.loggingEnabled=true&pbjs_debug=true`. This enables detailed logging from both the Permutive SDK and Prebid.js in your browser's developer console. Look for logs tagged with "permutiveRTD" to see exactly what the RTD module is doing, including which segments it's reading and which bidders it's attaching data to. For the Identity Manager module, look for "User ID" logs showing identity retrieval.
  </Accordion>
</AccordionGroup>

## Changelog

### July 2025

* Enhanced support for advertiser cohort activation via Prebid
* Improved Prebid RTD module configuration options

### June 2025

* Added support for PrebidAuctions event collection
* Enhanced bid data collection and auction insights

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