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

# ID5

> Integrate with ID5 for universal identity and programmatic 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;
      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/id5.svg?fit=max&auto=format&n=pNhz39ducTVcQczh&q=85&s=fa2dd8b27d24347cb137a0d8a88a23ec" alt="ID5" style={{ maxWidth: '32px', maxHeight: '32px', display: 'block' }} width="300" height="300" data-path="images/integrations/logos/id5.svg" />
    </div>

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

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

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

    <BadgeRowCenter label="Capability">
      <BadgeContainer>
        <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' }}>
    ID5 is a privacy-first universal identity platform that helps publishers maximize programmatic revenue through persistent cross-site user recognition.
  </p>
</Card>

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

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

## Overview

ID5 provides a universal identifier that enables publishers to identify users across different websites and platforms without relying on third-party cookies or deterministic identifiers like hashed emails. The ID5 integration with Permutive allows publishers to deploy ID5's identity solution through the Permutive SDK without additional implementation work.

This integration is a Destination integration:

* **Destination:** Permutive retrieves ID5's ephemeral identity envelopes and passes them to the programmatic bidstream via Prebid or Amazon Publisher Services (APS), enabling demand-side platforms (DSPs) to recognize users and improve match rates.

Key features of the ID5 integration:

* **Probabilistic Matching:** Identifies users across domains without requiring hashed emails
* **No-Code Integration:** Enable via Permutive dashboard without additional implementation
* **Privacy-First:** Ephemeral envelopes for bidstream use only, with automatic TCF consent handling

Use cases include:

* **Yield Optimization:** Enrich programmatic bids with ID5 identifiers to increase CPMs and fill rates
* Maximize addressability in a cookie-restricted environment

<Note>
  ID5 identifiers are not ingested into Permutive's identity graph. They are ephemeral signals generated at bid time and passed directly to the bidstream. These IDs cannot be used for Permutive cohort building, identity resolution, or data collaboration features.
</Note>

<Info>
  **Amazon Publisher Services (APS) Support**

  In addition to Prebid, this integration also supports Amazon Publisher Services (APS) for bidstream activation. APS support is currently available on request. If you're interested in using APS, please contact your Customer Success Manager to discuss setup and requirements.
</Info>

## Environment Compatibility

| Environment    | Supported    | Notes                                             |
| -------------- | ------------ | ------------------------------------------------- |
| **Web**        | <YesBadge /> | Full support via Permutive SDK and Prebid module  |
| **iOS**        | <NoBadge />  | Not supported - ID5 focuses on web-based identity |
| **Android**    | <NoBadge />  | Not supported - ID5 focuses on web-based identity |
| **CTV**        | <NoBadge />  | Not supported                                     |
| **API Direct** | <NoBadge />  | Not supported                                     |

## Prerequisites

Before enabling the ID5 integration, ensure you have the following. These prerequisites are for Prebid integration; for APS integration, contact your Customer Success Manager.

* **ID5 Partner Account:** You must sign up for an ID5 account to obtain your Partner ID. While ID5 is free for publishers to use (advertisers pay to decrypt the IDs), you need to register and accept their terms of service.
  * Sign up at [id5.io](https://id5.io) or contact ID5 directly
  * Obtain your unique Partner ID from your ID5 account dashboard

* **Consent Management:** ID5 must be added to your Consent Management Platform (CMP) as an approved vendor in your TCF vendor list. Without proper consent configuration, ID5 will not generate identifiers.
  * Add ID5 as a vendor in your TCF implementation
  * Ensure required TCF purposes are configured (consult ID5 documentation for specific requirements)

* **Prebid Integration:** The ID5 integration requires the Permutive Identity Manager Prebid module to be enabled. This is a specialized Prebid module separate from the standard Permutive RTD module.
  * The Permutive Identity Manager ID System module must be compiled into your Prebid build
  * See our [Prebid integration guide](/integrations/advertising/bidstream/prebid) for complete setup instructions including the Identity Manager module configuration

* **Permutive SDK:** The Permutive Web SDK must be deployed and operational on your website

## Setup

<Tabs>
  <Tab title="Primary Setup Steps">
    <Steps>
      <Step title="Sign Up for ID5 Account">
        Register for an ID5 account and obtain your Partner ID:

        1. Visit [id5.io](https://id5.io) and complete the publisher registration process
        2. Accept ID5's terms of service
        3. Navigate to your account dashboard and copy your Partner ID (you'll need this in the next step)

        <Note>
          ID5 is free for publishers to use. Advertisers pay to decrypt the identity envelopes in the bidstream.
        </Note>
      </Step>

      <Step title="Configure Consent Management">
        Add ID5 to your Consent Management Platform:

        1. Log in to your CMP dashboard
        2. Add ID5 to your TCF vendor list
        3. Ensure the required TCF purposes are enabled for ID5
        4. Test that consent is properly collected and ID5 appears in your consent string

        <Warning>
          If ID5 is not properly configured in your CMP, the integration will not generate identifiers, even if enabled in Permutive.
        </Warning>
      </Step>

      <Step title="Enable Prebid Identity Manager Module">
        Ensure the Permutive Identity Manager ID System module is included in your Prebid build:

        1. Check your current Prebid configuration or contact your Prebid implementation team
        2. If the module is not already included, rebuild Prebid with the `permutiveIdentityManagerIdSystem` module
        3. Deploy the updated Prebid build to your website

        <Info>
          The Permutive Identity Manager module is separate from the standard Permutive RTD module. Both can coexist in your Prebid setup. For detailed Prebid configuration instructions including the Identity Manager module setup, see our [Prebid integration guide](/integrations/advertising/bidstream/prebid).
        </Info>
      </Step>

      <Step title="Enable ID5 in Permutive Dashboard">
        Activate the ID5 integration in Permutive:

        1. Navigate to **Identity** → **Catalog** in your Permutive dashboard
        2. Locate **ID5** in the identity provider catalog
        3. Click **Connect** to begin the configuration process
        4. Enter your ID5 Partner ID when prompted
        5. Save the configuration

        The Permutive SDK will automatically begin retrieving ID5 identifiers on your next SDK build.
      </Step>

      <Step title="Verify Setup">
        Confirm that ID5 identifiers are being generated and passed to Prebid:

        1. Open your website in a browser with developer tools enabled
        2. Navigate to the **Console** tab
        3. Look for Permutive SDK log messages indicating ID5 initialization
        4. Check the **Network** tab for API calls to ID5's endpoints
        5. Inspect Prebid bid requests to verify that `eids` array contains ID5 identifiers

        **Expected behavior:**

        * ID5 API calls should complete successfully (HTTP 200)
        * Prebid bid requests should include ID5 in the `user.eids` array with source `id5-sync.com`

        <Expandable title="Example Prebid bid request with ID5">
          ```json theme={"dark"}
          {
            "user": {
              "eids": [
                {
                  "source": "id5-sync.com",
                  "uids": [
                    {
                      "id": "ID5*encrypted-id-envelope",
                      "atype": 1
                    }
                  ]
                }
              ]
            }
          }
          ```
        </Expandable>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Web">
    ### Web Implementation Details

    The ID5 integration operates entirely through the Permutive SDK and requires no additional code implementation from publishers. Once enabled in the dashboard:

    1. **SDK Initialization:** The Permutive SDK automatically detects the ID5 configuration during initialization
    2. **Consent Check:** The SDK verifies user consent via the TCF consent string
    3. **ID Retrieval:** If consent is granted, the SDK makes a client-side API call to ID5's servers to retrieve an ephemeral identity envelope
    4. **Prebid Activation:** The ID5 identifier is passed to the Permutive Identity Manager Prebid module
    5. **Bidstream Injection:** The Prebid module includes the ID5 identifier in the `user.eids` array of all bid requests

    ### Technical Flow

    ```mermaid theme={"dark"}
    sequenceDiagram
        participant Page as Publisher Page
        participant SDK as Permutive SDK
        participant CMP as Consent Management
        participant ID5 as ID5 API
        participant Prebid as Prebid.js

        Page->>SDK: SDK Initializes
        SDK->>CMP: Check TCF Consent
        CMP-->>SDK: Consent Granted
        SDK->>ID5: Request ID Envelope
        ID5-->>SDK: Return Encrypted ID
        SDK->>Prebid: Pass ID to Identity Manager
        Prebid->>Prebid: Include in bid requests
    ```
  </Tab>
</Tabs>

## Data Types

The ID5 integration does not collect event data into Permutive. Instead, it provides ephemeral identity signals that are passed directly to the programmatic bidstream via Prebid.

### Identity Signals Transmitted

<AccordionGroup>
  <Accordion title="ID5 Universal ID">
    An encrypted identity envelope generated by ID5 and passed to demand-side platforms through Prebid's Extended ID (EID) format.

    <ResponseField name="source" type="string">
      Always set to `id5-sync.com` to identify the ID5 provider in the bidstream
    </ResponseField>

    <ResponseField name="uids[].id" type="string">
      The encrypted ID5 identity envelope. This is an ephemeral identifier that varies across requests and cannot be used for long-term tracking
    </ResponseField>

    <ResponseField name="uids[].atype" type="integer">
      Authentication type indicator. Typically set to `1` for ID5 identifiers
    </ResponseField>

    <Note>
      ID5 identifiers are not stored in Permutive's identity graph or made available for cohort building. They exist solely for bidstream activation.
    </Note>
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="ID5 identifiers not appearing in bid requests">
    If ID5 identifiers are not showing up in your Prebid bid requests:

    **Check consent configuration:**

    * Verify ID5 is listed in your TCF vendor list
    * Ensure required TCF purposes are granted
    * Check the browser console for consent-related errors
    * Test in a fresh browser session or incognito mode to rule out cached consent states

    **Verify Prebid module:**

    * Confirm the Permutive Identity Manager ID System module is compiled into your Prebid build
    * Check that no Prebid configuration is blocking ID5 from the `eids` array
    * Review Prebid console logs for initialization errors

    **Confirm dashboard configuration:**

    * Navigate to Identity → Catalog in Permutive dashboard
    * Verify ID5 shows as "Connected" or "Enabled"
    * Ensure your Partner ID is correctly entered
    * Check that an SDK build has occurred since enabling ID5

    **Network connectivity:**

    * Check browser developer tools Network tab for failed API calls to ID5 endpoints
    * Verify no ad blockers or content security policies are blocking ID5 requests
    * Test from different networks to rule out firewall or proxy issues
  </Accordion>

  <Accordion title="ID5 account setup and Partner ID location">
    If you're having trouble obtaining your ID5 Partner ID:

    1. Ensure you've completed the full registration process at id5.io
    2. Check your email for a confirmation or welcome message from ID5 with account details
    3. Log in to your ID5 dashboard (the Partner ID is typically displayed prominently)
    4. Contact ID5 support directly if you cannot locate your Partner ID

    **Common issue:** Some publishers confuse the Partner ID with other ID5 identifiers. The Partner ID is a configuration value you provide to Permutive, not an identifier generated for users.
  </Accordion>

  <Accordion title="Low ID5 match rates or coverage">
    If you're seeing lower than expected ID5 coverage:

    **User consent factors:**

    * ID5 only generates identifiers for users who grant consent
    * In regions with strict privacy regulations (EU, California), consent rates may be lower
    * Review your consent management strategy and consent request UI

    **Technical factors:**

    * ID5 uses probabilistic matching, which may have inherent limitations in certain scenarios
    * Users with strict browser privacy settings may block ID5's signals
    * Safari's Intelligent Tracking Prevention (ITP) may limit ID5's effectiveness

    **Measurement:**

    * Use the Identity Insights dashboard in Permutive to view ID5 coverage metrics
    * Compare ID5 coverage to other identity solutions to establish a baseline
    * Monitor coverage trends over time to identify sudden changes that may indicate technical issues

    <Info>
      ID5 coverage naturally varies by geography, browser type, and user privacy preferences. Typical coverage rates depend on your specific audience characteristics.
    </Info>
  </Accordion>

  <Accordion title="ID5 integration conflicts with existing ID5 implementation">
    If you already have ID5 deployed directly on your site:

    The Permutive ID5 integration can coexist with direct ID5 implementations, but there may be redundant API calls. Consider:

    1. **Keep existing implementation:** If your direct ID5 integration is working well, you may not need the Permutive integration
    2. **Migrate to Permutive:** Remove your direct ID5 implementation and manage everything through Permutive for simplified operations
    3. **Coordinate with ID5:** Contact ID5 support to ensure both implementations are configured optimally

    **Performance consideration:** Running duplicate ID5 implementations may result in unnecessary API calls. Consolidating to a single implementation is recommended.
  </Accordion>

  <Accordion title="No visible impact on programmatic revenue">
    If you've enabled ID5 but haven't seen changes in CPMs or fill rates:

    **Measurement timeframe:**

    * Allow at least 2-4 weeks for measurable impact
    * Programmatic revenue fluctuates naturally; compare periods before and after ID5 enablement

    **Demand-side adoption:**

    * Not all DSPs and advertisers decrypt and utilize ID5 identifiers
    * The value of ID5 depends on your specific demand partners
    * Contact your SSP or programmatic partners to confirm they support ID5

    **Analysis approach:**

    * Review Prebid analytics to see bid density changes in auctions with ID5 present
    * Compare win rates for bid requests with vs. without ID5 identifiers
    * Consult with your ad operations team or programmatic partner for detailed analysis

    <Note>
      ID5's value proposition varies by publisher based on audience composition, demand partners, and existing identity solutions. Some publishers see significant uplift, while others see minimal impact.
    </Note>
  </Accordion>
</AccordionGroup>

## Changelog

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