User ID Module

• Overview
• How It Works
• User ID, GDPR, Permissions, and Opt-Out
  • Publisher First Party Opt-Out
• Basic Configuration
• Permissions
• User ID Sub-Modules
  • AkamaiDAPId
    • AkamaiDAPId Configuration
  • AdmixerID
    • AdmixerID Configuration
    • AdmixerID Examples
  • AMX RTB ID
    • AMX RTB ID Configuration
  • BritePool
    • BritePool Registration
    • BritePool Configuration
    • BritePool Examples
  • Criteo ID for Exchanges
    • Criteo ID Configuration
    • Criteo ID Example
  • Deepintent DPES ID by Deepintent
    • Deepintent DPES ID Registration
    • Deepintent DPES ID Configuration
    • Deepintent DPES ID Examples
  • DMD ID by DMD Marketing Corp
    • DMD ID Registration
    • DMD ID Configuration
    • DMD ID Example
  • Fabrick ID by Neustar
    • Fabrick Registration
    • Fabrick Configuration
    • Fabrick Examples
  • FLoC ID
    • FLoC ID Configuration
    • FLoC Example
  • Halo ID from Audigent
    • HaloId Configuration
  • ID+
    • ID+ Registration
    • ID+ Example
  • ID5 Universal ID
    • ID5 Universal ID Registration
    • ID5 Universal ID Configuration
      • A Note on A/B Testing
    • ID5 Universal ID Examples
  • IDx
    • IDx Registration
    • IDx Configuration
    • IDx Example
  • Intent IQ ID
    • Intent IQ ID Registration
    • Intent IQ ID Configuration
    • Intent IQ ID Examples
  • LiveIntent nonID
    • LiveIntent ID Registration
    • How does LiveIntent ID work
    • LiveIntent ID configuration
    • LiveIntent ID examples
  • Lotame Panorama ID
    • Lotame Panorama ID Configuration
    • Lotame Panorama ID Example
  • MediaWallah OpenLinkID
    • MediaWallah OpenLinkID Registration
    • MediaWallah OpenLinkID Configuration
    • MediaWallah OpenLinkID Examples
  • Merkle ID
    • Merkury by Merkle ID Examples
  • netID
    • netID Examples
  • NextRoll ID
    • NextRoll ID Registration
    • NextRoll ID Configuration
  • Novatiq Snowflake ID
    • Novatiq Snowflake ID Configuration
  • Parrable ID
    • Parrable ID Registration
    • Parrable ID Configuration
    • Timezone and Timezone Offset Filtering
    • Parrable ID Examples
  • RampID
    • RampID Registration
    • RampID Configuration
    • RampID Examples
  • SharedID
    • SharedID ID Configuration
    • SharedID Examples
  • PubProvided ID
    • PubProvided Configuration
  • Quantcast ID
    • Quantcast ID Configuration
    • Quantcast ID Example
  • Tapad ID
    • Tapad ID Configuration
    • Tapad ID Example
  • Unified ID
    • Unified ID Registration
    • Unified ID Configuration
    • Unified ID Examples
  • Unified ID 2.0
    • Unified ID Registration
    • Unified ID 2 Configuration
    • Unified ID 2 Example
  • Verizon Media ConnectID
    • Verizon Media ConnectID Registration
    • Verizon Media ConnectID Configuration
    • Verizon Media ConnectID Examples
• Adapters Supporting the User ID Sub-Modules
• Bidder Adapter Implementation
  • Prebid.js Adapters
  • Prebid Server Adapters
  • Exporting User IDs
• ID Providers
• Passing UserIds to Google Ad Manager for targeting
• Further Reading

Overview

The User ID module supports multiple ways of establishing pseudonymous IDs for users, which is an important way of increasing the value of header bidding. Instead of having several exchanges sync IDs with dozens of demand sources, a publisher can choose to integrate with any of a number of ID schemes.

How It Works

1. The publisher determines which user ID modules to add to their Prebid.js package and consults with their legal counsel to determine the appropriate user disclosures.
2. The publisher builds Prebid.js by specifying one or more ID sub-modules they would like to include. e.g. “gulp build –modules=____IdSystem”. You also need to add the userId module to your Prebid.js distribution.
3. The page defines User ID configuration in pbjs.setConfig()
4. When setConfig() is called, and if the user has consented to storing IDs locally, the module is invoked to call the URL if needed
   1. If the relevant local storage is present, the module doesn’t call the URL and instead parses the scheme-dependent format, injecting the resulting ID into bidRequest.userId.
   2. If GDPR applies, the consent signal from the CMP is hashed and stored in a cookie called _pbjs_userid_consent_data. This is required so that ID sub-modules may be called to refresh their ID if the user’s consent preferences have changed from the previous page, and ensures cached IDs are no longer used if consent is withdrawn.
5. An object containing one or more IDs (bidRequest.userId) is made available to Prebid.js adapters and Prebid Server S2S adapters.
6. In addition to bidRequest.userId, bidRequest.userIdAsEids is made available to Prebid.js adapters and Prebid Server S2S adapters. bidRequest.userIdAsEids has userIds in ORTB EIDS format.

Note that User IDs aren’t needed in the mobile app world because device ID is available in those ad serving scenarios.

Note that not all bidder adapters support all forms of user ID. See the tables below for a list of which bidders support which ID schemes.

As of Prebid 4.0, this module will attempt storage in the main domain of the publisher’s website instead of a subdomain, unless this behavior is overriden by a submodule.

User ID, GDPR, Permissions, and Opt-Out

When paired with the Consent Management module, privacy rules are enforced:

• The module checks the GDPR consent string
• If no consent string is available OR if the user has not consented to Purpose 1 (local storage):
  • Calls to an external user ID vendor are not made.
  • Nothing is stored to cookies or HTML5 local storage.

In addition, individual users may opt-out of receiving cookies and HTML5 local storage by setting these values:

• _pbjs_id_optout cookie or HTML5 local storage. The value can be anything – if it exists, the user is considered opted out and no userId modules will fire.
• _pubcid_optout cookie or HTML5 local storage. This is for backwards compatibility with the original PubCommonID module, as of 5.0 known as the SharedId module. Likewise, the value can be anything.

Publisher First Party Opt-Out

Without third-party cookies, mechanisms like the NAI don’t work, so some publishers may want to implement a first party opt-out so their users aren’t tagged with first party cookies containing IDs.

Publishers that want to do this should design their workflow and then set _pbjs_id_optout cookie or HTML5 local storage. For instance:

• read from an in-page javascript variable and set _pbjs_id_optout to any value.
• call an in-page function and use the results to create a _pbjs_id_optout cookie with any value.

Basic Configuration

By including this module and one or more of the sub-modules, a number of new options become available in setConfig(), all of them under the userSync object as attributes of the userIds array of sub-objects. The table below has the options that are common across ID systems. See the sections below for specific configuration needed by each system and examples.

Permissions

Publishers can control which user ids are shared with the bid adapters they choose to work with by using the bidders array. The bidders array is part of the User id module config, publisher may choose to send an id to some bidders but not all, the default behavior is that each user id go to all bid adapters the publisher is working with.

Use the optional bidders parameter to define an array of bidder codes to which this user ID may be sent.

In this example the SharedID sub adapter is only allowed to be sent to the Rubicon adapter.

userIds: [
  {
    name: "sharedId",
    bidders: [
      'rubicon'
    ],
    params: {
      syncTime: 60,      // in seconds
      defaultis24hours
    },
    storage: {
      type: "cookie",
      name: "sharedid",
      expires: 28        // in days
    }
  }
]

The Rubicon bid adapter would then receive

{
  "bidder": "rubicon",
  ...
  "userId": {
    "sharedid": {
      "id": "01*******",
      "third": "01E*******"
    }
  },
  "userIdAsEids": [
    {
      "source": "sharedid.org",
      "uids": [
        {
          "id": "01**********",
          "atype": 1,
          "ext": {
            "third": "01***********"
          }
        }
      ]
    }
  ],
  ...
}

User ID Sub-Modules

AkamaiDAPId

The Akamai Data Activation Platform (DAP) is a privacy-first system that protects end-user privacy by only allowing them to be targeted as part of a larger cohort. DAP views hiding individuals in large cohorts as the best mechanism to prevent unauthorized tracking.

The integration of DAP into Prebid.JS consists of creating a UserID plugin that interacts with the DAP API. The UserID module tokenizes the end-user identity into an ephemeral, secure pseudonymization called a dapId. The dapId is then supplied to the bid-stream where the SSP partner looks up cohort membership for that token, and supplies the cohorts to the rest of the bid-stream.

In this system, no end-user identifier is supplied to the bid-stream, only cohorts. This is a foundational privacy principal DAP is built upon.

AkamaiDAPId Configuration

First, make sure to add the DAP submodule to your Prebid.js package with:

gulp build --modules=akamaiDAPIdSystem,userId

The following configuration parameters are available:

pbjs.setConfig({
  userSync: {
    userIds: [{
      name: 'akamaiDAPId',
      params: {
        apiHostname: '<see your Akamai account rep>',
        domain: 'your-domain.com',
        type: 'email' | 'mobile' | ... | 'dap-signature:1.0.0',
        identity: ‘your@email.com’ | ‘6175551234' | ...,
        apiVersion: 'v1' | 'x1',
        attributes: '{ "cohorts": [ "3:14400", "5:14400", "7:0" ],"first_name": "...","last_name": "..." }'
      },
    }],
    auctionDelay: 50             // 50ms maximum auction delay, applies to all userId modules
  }
});

In order to make use of v1 APIs, “apiVersion” needs to explicitly mention ‘v1’. The “apiVersion” defaults to x1 if not specified. “attributes” can be configured in x1 API only and not v1 APIs. Please ensure that the “attributes” value is in same format as shown above.

Contact Prebid@akamai.com(Akamai account rep) for apiHostname.

AdmixerID

Admixer ID, provided by [Admixer] (https://admixer.com/), is a universal ID solution that doesn’t rely on 3rd party cookies and helps publishers and advertisers to recognize users across various browsers and environments. Our sub adapter takes deterministic signals like email and phone as input and returns an anonymous id that unlocks access to a wide range of Admixer’s demand sources, amplifying audience segmentation, targeting and measurement.

The Admixer privacy policy is at https://admixer.com/privacy/

Add Admixer ID module to your Prebid.js package with:

gulp build –modules=admixerIdSystem

AdmixerID Configuration

AdmixerID Examples

1) Individual params may be set for the Admixer ID Submodule.

   pbjs.setConfig({
       userSync: {
           userIds: [{
               name: "admixerId",
               storage: {
                   name: "admixerId",
                   type: "cookie",
                   expires: 30
               },
               params: {
                   pid: "4D393FAC-B6BB-4E19-8396-0A4813607316", // example id
                   e: "3d400b57e069c993babea0bd9efa79e5dc698e16c042686569faae20391fd7ea", // example hashed email (sha256)
                   p: "05de6c07eb3ea4bce45adca4e0182e771d80fbb99e12401416ca84ddf94c3eb9" //example hashed phone (sha256)
               }
           }],
           auctionDelay: 50             // 50ms maximum auction delay, applies to all userId modules
       }
   });

AMX RTB ID

The AMX RTB ID is a first-party identifier designed for publishers using the AMX RTB adapter. For more information please contact prebid@amxrtb.com

AMX RTB ID Configuration

First, add the AMX RTB ID module to your Prebid.js build:

gulp build --modules=userId,amxIdSystem

Then configure the amxId in your userSync configuration:

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'amxId',
            storage: {
                name: 'amxId',
                type: 'html5',
                expires: 14,
            }
        }]
    }
});

This will add a userId.amxId property to all bidRequests. This will be read by the AMX RTB bid adapter, and any other adapters that support EIDs:

{
  amxId: '3ca11058-ecbc-419f-bda7-b52fe7baf02a'
}

BritePool

The BritePool ID is a persistent identifier that enables identity resolution for people-based marketing in the cookieless world. Every BritePool ID is associated with a real identity. As a result, publishers, SSPs and DSPs that integrate with BritePool, or automated integration partners (such as PubMatic), are able to maximize revenues without cookies. As addressable individuals visit publisher websites and mobile apps, the BritePool IDs associated with these identities are passed into the bidstream; enabling advertisers to transact against these BritePool ID’s and publishers to maximize the revenues associated with their inventory and audience. The BritePool ID combines consumer privacy with easy, rapid integration for publishers and does not significantly increase the computing resources required of DSPs and SSPs.

Add it to your Prebid.js package with:

gulp build –modules=britepoolIdSystem

BritePool Registration

Please reach out to prebid@britepool.com and request your api_key.

The BritePool privacy policy is at https://britepool.com/services-privacy-notice/.

BritePool Configuration

BritePool Examples

1) Individual params may be set for the BritePool User ID Submodule. At least one identifier must be set in the params.

   pbjs.setConfig({
       userSync: {
           userIds: [{
               name: "britepoolId",
               storage: {
                   name: "britepoolid",
                   type: "cookie",
                   expires: 30
               },
               params: {
                   url: "https://sandbox-api.britepool.com/v1/britepool/id", // optional. used for testing
                   api_key: "xxx", // provided by britepool
                   hash: "yyyy", // example identifier
                   ssid: "r894hvfnviurfincdejkencjcv" // example identifier
               }
           }],
           syncDelay: 3000 // 3 seconds after the first auction
       }
   });

Criteo ID for Exchanges

Criteo is the leading advertising platform for the Open Internet. The Criteo ID for Exchanges module enables publishers to access Criteo’s unique demand - more than 20.000 advertisers & brands - to monetize their exchange inventory with an optimal take rate across all browsing environments. Note that direct access to that demand is also available through Criteo Direct Bidder, in which case this module is unnecessary.

The Criteo privacy policy is at https://www.criteo.com/privacy/.

Add it to your Prebid.js package with:

gulp build –modules=criteoIdSystem

Criteo ID Configuration

The Criteo ID module does not require any configuration parameters. It should work as-is provided that bidders use it in their adapters. When calling Criteo RTB, partners should forward this id in the field user.ext.prebid_criteoid.

NOTE: For optimal performance, the Criteo Id module should be called at every opportunity. It embeds its own optimal caching mechanism. It’s best not to use params.storage with this module as it may only lower the performances. If you are using multiple id systems, however, you may use it for the other id systems that supports it.

Criteo ID Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "criteo",
        }]
    }
});

Deepintent DPES ID by Deepintent

The DeepIntent Healthcare Marketing Platform is the first and only DSP that combines real-world health data, premium partnerships, and custom integrations to reach patients and providers across any device. DeepIntent empowers publishers to maximize their inventory, collaborate and transact directly with advertisers, and grow their business in a safe, controlled, transparent, and privacy-compliant way. Our publisher partners sell inventory on every channel via real-time bidding or conducting one-to-one trading with hundreds of the country’s leading healthcare brands and agencies.

DeepIntent’s DPES ID is a shared user identifier built for healthcare marketers and publishers integrated within DeepIntent’s Healthcare Marketplace. The DPES ID lets users protect and manage their privacy throughout the advertising value chain. User data written and associated with the DPES ID is not stored on DeepIntent’s servers. Instead, this data is stored in a decentralized way on a user’s browser. Users can still opt out of the ads by navigating to https://option.deepintent.com/adchoices

Deepintent DPES ID Registration

DPES ID is free to use and requires a simple registration with DeepIntent. Please reach out to DeepIntent’s Publisher Development team at prebid@deepintent.com to learn more and get started. Once a publisher registers with DeepIntent’s platform, DeepIntent will provide a simple code snippet to be integrated with the publisher’s website. This code snippet will capture and store information per the publisher’s end user agreement. The DPES User ID module uses the DPES ID by passing it within the DeepIntent Prebid adapter.

Deepintent DPES ID Configuration

Deepintent DPES ID Examples

1) Publisher stores the hashed identity from healthcare identity in cookie

pbjs.setConfig({
  userSync: {
    userIds: [{
      name: 'deepintentId',
      storage: {
        type: 'cookie',           // "html5" is the required storage type option is "html5"
        name: '_dpes_id',            
        expires: 90             // storage lasts for 90 days, optional if storage type is html5
      }
    }],
    auctionDelay: 50             // 50ms maximum auction delay, applies to all userId modules
  }
});

2) Publisher stores the hashed identity from healthcare identity in localstorage

pbjs.setConfig({
  userSync: {
    userIds: [{
      name: 'deepintentId',
      storage: {
        type: 'html5'           // "html5" is the required storage type option is "html5"
        name: '_dpes_id'
      }
    }],
    auctionDelay: 50             // 50ms maximum auction delay, applies to all userId modules
  }
});

DMD ID by DMD Marketing Corp

DMD is the preeminent supplier of US-based healthcare professional (HCP) identity data to the pharmaceutical, health system and medical publishing industries. DMD is the only data provider that has acquired its deterministic identity data through a fully consented, first-party, opt-in process. DMD’s privacy policy that can be found at Privacy Policy.

For assistance setting up your module, please contact us at prebid@dmdconnects.com

Add the DMD ID to your Prebid.js Package with:

gulp build –modules=userId,dmdIdSystem

DMD ID Registration

Please reach out to prebid@dmdconnects.com to request your api_key

DMD ID Configuration

DMD ID Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'dmdId',
            params: {
                api_key: '3fdbe297-3690-4f5c-9e11-ee9186a6d77c' // provided to you by DMD
            }
        }]
    }
});

Fabrick ID by Neustar

Neustar Fabrick™ is a unified identity ecosystem that powers connections between brands, publishers, and consumers to accelerate marketing performance across online and offline channels.

Add it to your Prebid.js package with:

gulp build –modules=fabrickIdSystem

Fabrick Registration

Please reach out to FabrickIntegrations@team.neustar to request your apiKey.

Fabrick Configuration

Fabrick Examples

1) Publisher passes an apiKey and hashed email address and elects to store the Fabrick ID envelope in a cookie.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'fabrickId',
            params: {
                apiKey: '123456789', // provided to you by Neustar
                e: '31c5543c1734d25c7206f5fd591525d0295bec6fe84ff82f946a34fe970a1e66' // example hashed email address (sha256)
            },
            storage: {
                name: 'pbjs_fabrickId',
                type: 'cookie',
                expires: 7
            }
        }]
    }
});

2) Publisher passes an apiKey and hashed email address and elects to store the fabrickId envelope in HTML5 localStorage.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'fabrickId',
            params: {
                apiKey: '123456789', // provided to you by Neustar
                e: '31c5543c1734d25c7206f5fd591525d0295bec6fe84ff82f946a34fe970a1e66' // example hashed email address (sha256)
            },
            storage: {
                type: "html5",
                name: "pbjs_fabrickId",
                expires: 7
            }
        }]
    }
});

FLoC ID

The Federated Learning of Cohorts (FLoC) system provides a privacy-preserving mechanism for interest-based ad selection. As a user moves around the web, their browser uses the FLoC algorithm to work out an “interest cohort”, which will be the same for thousands of browsers with a similar recent browsing history. The user’s browser is associated with one interest cohort at a time and recalculates its cohort periodically (currently once every seven days during this initial origin trial) on the user’s device, without sharing individual browsing data with the browser vendor or anyone else.

There are two important things to note when using the FLoC Userid Sub adapter.

1. Unlike other user id subadapters FLoC ids cannot be stored in a cookie or Local Storage. FLoC ids change periodically and should always be fetched from the FLoC API

2. The function (getGlobal()).getUserIds returns userId.flocId.id=value into the bid request NOT userid.userIdAsEids.

To include the FLoC user id module use:

$ gulp build --modules=flocIdSystem

Note: FLoC is still in a trial period. How to take part in the FLoC origin trial. During the trial, a token is required. Publishers may get their own token or use sharedid’s token if they choose. Use this without the line breaks: A3dHTSoNUMjjERBLlrvJSelNnwWUCwVQhZ5tNQ+sll7y+LkPPVZXtB77u2y7CweRIxiYaGw GXNlW1/dFp8VMEgIAAAB+eyJvcmlnaW4iOiJodHRwczovL3NoYXJlZGlkLm9yZzo0NDMiLC JmZWF0dXJlIjoiSW50ZXJlc3RDb2hvcnRBUEkiLCJleHBpcnkiOjE2MjYyMjA3OTksImlzU 3ViZG9tYWluIjp0cnVlLCJpc1RoaXJkUGFydHkiOnRydWV9

FLoC ID Configuration

FLoC Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "flocId",
            params: {
              "token": "Registered token" // see above for sharedId's FLoC token
            }
        }],
        syncDelay: 3000              // 3 seconds after the first auction
    }
});

Halo ID from Audigent

Audigent is a next-generation data management platform and a first-of-a-kind “data agency” containing some of the most exclusive content-consuming audiences across desktop, mobile and social platforms. Our HaloId module allows for user id resolution and Audigent user data segmentation to be retrieved for users across the web. For assistance setting up your module please contact us at prebid@audigent.com.

HaloId Configuration

Add the Halo ID system to your Prebid.js package with:

gulp build –modules=userId,haloIdSystem

Add HaloId to the userSync configuration.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'haloId',
            storage: {
                name: 'haloId',
                type: 'html5'
            }
        }]
    }
});

The request.userId.haloId will contain the Audigent HaloId and associated segments:

{
  "haloId": "user-halo-id",
  "auSeg": ["segment1", "segment2"]
}

ID+

ID+, powered by zeotap, enables the marketing ecosystem to overcome challenges posed by the demise of identifiers and a fast-changing regulatory landscape. ID+ is an open invitation to the entire industry to build the future of identity together.

This sub-module enables the user’s ID+ to be available in the bid request.

More information on ID+ can be found here: https://idplus.io/

Add it to your Prebid.js package with:

gulp build –modules=zeotapIdPlusIdSystem

ID+ Registration

You can set up your ID+ account by contacting our support team at support.idplus@zeotap.com or via https://idplus.io/contact-us and we will get back to you.

ID+ is covered under zeotap privacy policy: Zeotap Privacy Policy.

ID+ Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "zeotapIdPlus"
        }]
    }
});

ID5 Universal ID

The ID5 Universal ID is a shared, neutral identifier that publishers and ad tech platforms can use to recognise users even in environments where 3rd party cookies are not available. The ID5 Universal ID is designed to respect users’ privacy choices and publishers’ preferences throughout the advertising value chain. For more information about the ID5 Universal ID and detailed integration docs, please visit our documentation. We also recommend that you sign up for our release notes to stay up-to-date with any changes to the implementation of the ID5 Universal ID in Prebid.

ID5 Universal ID Registration

The ID5 Universal ID is free to use, but requires a simple registration with ID5. Please visit id5.io/universal-id to sign up and request your ID5 Partner Number to get started.

The ID5 privacy policy is at https://www.id5.io/platform-privacy-policy.

ID5 Universal ID Configuration

First, make sure to add the ID5 submodule to your Prebid.js package with:

gulp build –modules=id5IdSystem,userId

The following configuration parameters are available:

NOTE: The ID5 Universal ID that is delivered to Prebid is encrypted by ID5 with a rotating key to enforce privacy requirements and avoid unauthorized usage. Therefore, we strongly recommend setting storage.refreshInSeconds to 8 hours (8*3600 seconds) to ensure all demand partners receive an ID that has been encrypted with the latest key, has up-to-date privacy signals, and allows them to transact against it.

A Note on A/B Testing

Publishers may want to test the value of the ID5 ID with their downstream partners. While there are various ways to do this, A/B testing is a standard approach. Instead of publishers manually enabling or disabling the ID5 User ID Module based on their control group settings (which leads to fewer calls to ID5, reducing our ability to recognize the user), we have baked this in to our module directly.

To turn on A/B Testing, simply edit the configuration (see above table) to enable it and set what percentage of users you would like to set for the control group. The control group is the set of user where an ID5 ID will not be exposed in to bid adapters or in the various user id functions available on the pbjs global. An additional value of ext.abTestingControlGroup will be set to true or false that can be used to inform reporting systems that the user was in the control group or not. It’s important to note that the control group is user based, and not request based. In other words, from one page view to another, a user will always be in or out of the control group.

ID5 Universal ID Examples

ATTENTION: As of Prebid.js v4.14.0, ID5 requires storage.type to be "html5" and storage.name to be "id5id". Using other values will display a warning today, but in an upcoming release, it will prevent the ID5 module from loading. This change is to ensure the ID5 module in Prebid.js interoperates properly with the ID5 API and to reduce the size of publishers’ first-party cookies that are sent to their web servers. If you have any questions, please reach out to us at prebid@id5.io.

Publisher wants to retrieve the ID5 Universal ID through Prebid.js

pbjs.setConfig({
  userSync: {
    userIds: [{
      name: 'id5Id',
      params: {
        partner: 173,            // change to the Partner Number you received from ID5
        pd: 'MT1iNTBjY...',      // optional, see table above for a link to how to generate this
        abTesting: {             // optional
          enabled: true,         // false by default
          controlGroupPct: 0.1   // valid values are 0.0 - 1.0 (inclusive)
        }
      },
      storage: {
        type: 'html5',           // "html5" is the required storage type
        name: 'id5id',           // "id5id" is the required storage name
        expires: 90,             // storage lasts for 90 days
        refreshInSeconds: 8*3600 // refresh ID every 8 hours to ensure it's fresh
      }
    }],
    auctionDelay: 50             // 50ms maximum auction delay, applies to all userId modules
  }
});

IDx

IDx, a universal ID solution provided by Retargetly, is the evolution of digital identifiers for the Latin American region. Through a proprietary identity graph, it allows publishers, advertisers, and ad tech platforms to recognize users across domains and devices even where third party cookies aren’t available.

The IDx platform is designed with privacy at its core and allows for nearly every conceivable digital use case including but not limited to audience targeting, retargeting, frequency management, personalization, and total reach reporting.

Add it to your Prebid.js package with:

gulp build –modules=idxIdSystem

IDx Registration

If you are a publisher or an advertiser, then IDx is free to use but requires a simple registration process. To do this, please send an email to idx-partners@retargetly.com to request your IDx Partner ID.

We may ask for some basic information from you before approving your request. For more information on IDx, please visit retargetly.com/idx.

IDx Configuration

IDx Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "idx"
        }]
    }
});

Intent IQ ID

Intent IQ’s universal ID with its unparalleled coverage of over 80% of ad inventory, protects publishers’ ability to rely on advertising as their main revenue source while preserving user privacy in a third party cookieless world.

The universal ID is an Intent IQ generated alphanumeric characters ID representing a person. This ID is not matched with personal information and remains anonymous to Intent IQ.

Intent IQ universal ID enables partners - publishers, SSPs, DSPs, DMPs and advertisers to support, in a privacy-friendly way, and on a person level, core elements of the advertising business model -

• Targeting across sites and devices
• Frequency capping
• Attribution measurement across sites and devices

Intent IQ’s universal ID works across IP addresses and user-agent changes.

Intent IQ’s universal ID truly stands out in the coverage and accuracy it provides. Intent IQ’s universal ID covers over 80% of ad inventory with 90% accuracy. By contrast, third-party cookies offer 56% coverage and log-in solutions offer coverage of less than 20%.

Add it to your Prebid.js package with:

gulp build –modules=intentIqIdSystem

Intent IQ ID Registration

You can set up Intent IQ ID by contacting our operations team at Intent IQ Contact Us and getting your partner id.

The Intent IQ ID privacy is covered under the Intent IQ Privacy Policy.

Intent IQ ID Configuration

NOTE: The Intent IQ ID is encrypted with a key that changes every several hours. Demand partners utilize the latest key to decrypt the ID and use it. Therefore, to enable demand partners have an ID they can use, we highly recommend calling Intent IQ every 4 hours by setting storage.refreshInSeconds to 4 hours (4*3600 seconds)

Intent IQ ID Examples

1) Publisher has a partner ID from Intent IQ and cookies.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "intentIqId",
            params: {
                partner: 123456             // valid partner id
            },
            storage: {
                type: "cookie",
                name: "intentIqId",         // create a cookie with this name
                expires: 60,                // cookie can last for 60 days
                refreshInSeconds: 4*3600    // refresh ID every 4 hours to ensure it's fresh
}
        }],
        syncDelay: 3000              // 3 seconds after the first auction
    }
});

2) Publisher supports Intent IQ and HTML5 local storage.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "intentIqId",
            params: {
                partner: 123456			    // valid partner id
            },
            storage: {
                type: "html5",
                name: "intentIqId",         // set localstorage with this name
                expires: 60,
                refreshInSeconds: 4*3600    // refresh ID every 4 hours to ensure it's fresh
            }
        }],
        syncDelay: 3000
    }
});

3) Publisher supports IntentIQ and HTML5 local storage with extra dynamic params such as ‘pcid’ and ‘pai’.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "intentIqId",
            params: {
                partner: 123456     // valid partner id
                pcid: PCID_VARIABLE   // string value, dynamically loaded into a variable before setting the configuration
                pai: PAI_VARIABLE   // string value, dynamically loaded into a variable before setting the configuration
            },
            storage: {
                type: "html5",
                name: "intentIqId",    // set localstorage with this name
                expires: 60
            }
        }],
        syncDelay: 3000
    }
});

LiveIntent nonID

LiveIntent offers audience resolution by leveraging our next-generation identity solutions. The LiveIntent identity graph is built around a people-based set of data that is authenticated daily through active engagements with email newsletters and media across the web. The LiveIntent nonID is a user identifier tied to an active, encrypted email in our graph and functions in cookie-challenged environments and browsers.

There are two ways to build your Prebid.js package to include the LiveIntent nonID:

• The standard version which allows publishers to include the module with full functionalities, like hashing email addresses and identity resolution
• The minimal version, which allows publishers to deploy a smaller bundle with minimal features, including identity resolution.

Add the full LiveIntent Identity module to your Prebid.js package with:

gulp build –modules=userId,liveIntentIdSystem

Add the minimal LiveIntent Identity module to your Prebid.js package with:

LiveConnectMode=minimal gulp build –modules=liveIntentIdSystem

The request.userId.lipb object would look like:

{
  "lipbid": "T7JiRRvsRAmh88",
  "segments": ["999"]
}

The adapters can be implemented to use the lipbid as the identifier and segments to which that identifier is associated with. To enable identity resolution for a specific publisher, LiveIntent builds a model on the backend with data collected via an additional call issued on each page load.

LiveIntent ID Registration

Please register with us if you’re not already a LiveIntent customer: https://www.liveintent.com/prebid-registration/

LiveIntent’s privacy policies for the services rendered can be found at https://www.liveintent.com/services-privacy-policy/

How does LiveIntent ID work

The LiveIntent ID sub-module resolves the identity of audiences by connecting impression opportunities to a stable identifier - the nonID. In order to provide resolution one or more first-party cookies are used to create a stable identifier.

How does LiveIntent ID sub-module decide, which first-party cookies to use:

1. By default LiveIntent ID sub-module generates its own first-party identifier on the publisher’s domain. Publishers have the option to disable the cookie generation when configuring the LiveIntent ID sub-module.
2. A publisher can also define in the configuration which additional first-party cookies should be used. These can be used in a combination with the LiveIntent first-party cookie.

The LiveIntent ID sub-module sends the defined identifiers to the identity graph, which processes them and creates a nonID. The parameters being sent are described here

For the identity resolution the LiveIntent ID sub-module makes a request to LiveIntent’s identity resolution API, which returns a nonID and the audience segment(s) a user belongs to. The nonID and the segment ID are then exposed by the Prebid User ID Module to Prebid adapters to be sent out in a bid request. An SSP can then make the impression opportunity available to any buyers targeting the segment.

The first-party cookie generation and identity resolution functionality is provided by the LiveConnect JS library, included within the LiveIntent ID sub-module. LiveIntent has created a shared library that is open source, available at https://www.npmjs.com/package/live-connect-js.

The LiveIntent ID sub-module follows the standard Prebid.js initialization based on the GDPR consumer opt-out choices. With regard to CCPA, the LiveConnect JS receives a us_privacy string from the Prebid US Privacy Consent Management Module and respects opt-outs.

LiveIntent ID configuration

LiveIntent ID examples

1. To receive the LiveIntent ID, the setup looks like this.

   pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "liveIntentId",
            params: {
              publisherId: "9896876"
            },
            storage: {
            type: “cookie”,
            name: “pbjs_li_nonid”,    //create a cookie with this name
            expires: 1                // cookie is stored for 1 day
            }
        }]
    }
   })
   

2. If you are passing additional identifiers that you want to resolve to the LiveIntent ID, add those under the identifiersToResolve array in the configuration parameters.

   pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "liveIntentId",
            params: {
              publisherId: "9896876",
              identifiersToResolve: ["my-own-cookie"]
            },
            storage: {
            type: “cookie”,
            name: “pbjs_li_nonid”,    //create a cookie with this name
            expires: 1                // cookie is stored for 1 day
            }
        }]
    }
   })
   

3. If all the supported configuration params are passed, then the setup looks like this.

   pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "liveIntentId",
            params: {
              publisherId: "9896876",
              identifiersToResolve: ["my-own-cookie"],
              url: "https://publisher.liveintent.com/idex",
              partner: "prebid",
              ajaxTimeout: 1000,
              liCollectConfig: {
                fpiStorageStrategy: "cookie",
                fpiExpirationDays: 730,
                collectorUrl: "https://rp.liadm.com",
                appId: "a-0012"
              }
            },
            storage: {
            type: “cookie”,
            name: “pbjs_li_nonid”,    //create a cookie with this name
            expires: 1                // cookie is stored for 1 day
            }
        }]
    }
   })
   

Lotame Panorama ID

Lotame Panorama is a suite of data-enrichment solutions for digital advertising that empowers marketers, agencies, publishers and media companies to transform consumer personas into addressable audiences. At the heart of Lotame Panorama is the Panorama ID, a people-based identifier powered by deterministic and probabilistic data, available across the cookie-challenged web and all browsers.

The Lotame privacy policy is at https://www.lotame.com/about-lotame/privacy/. If you have any questions about Panorama ID, please reach out by emailing prebid@lotame.com.

Add it to your Prebid.js package with:

gulp build –modules=lotamePanoramaIdSystem

Lotame Panorama ID Configuration

The Lotame Panorama ID module does not require any configuration parameters. It should work as-is provided that bidders use it in their adapters.

NOTE: For optimal performance, the Lotame Panorama Id module should be called at every opportunity. It is best not to use params.storage with this module as the module has its own optimal caching mechanism.

Lotame Panorama ID Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "lotamePanoramaId",
        }]
    }
});

MediaWallah OpenLinkID

MediaWallah’s openLink is an anonymous person based ID that enables buyers and sellers of media to connect a person and their devices across the web and mobile apps. openLink facilities the buying of media between DSPs, SSPs and publishers.

Add support for MediaWallah OpenLinkID to your Prebid.js package with:

gulp build –modules=userId,mwOpenLinkIdSystem

MediaWallah OpenLinkID Registration

MediaWallah requires the creation of an accountId a partnerId in order to take advantage of openLink. Please contact your partner resource to get these Ids provisioned.

MediaWallah OpenLinkID Configuration

MediaWallah OpenLinkID Examples

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'mwOpenLinkId',
            params: {
                accountId: '1000',
                partnerId: '1001',
                uid: 'u-123xyz'
            }
        }]
    }
})

Merkle ID

Merkury by Merkle enables marketers, media owners, and publishers to own, build, and control a cookie-less Private Identity Graph. Merkury uses an organization’s first-party CRM data and valuable interactions such as logins, outbound email campaigns and media reach to create and grow a universe of person-based IDs for cross-channel targeting, personalization, measurement and more.

Merkury by Merkle ID Examples

Publisher stores Merkury by Merkle in local storage for 30 days

pbjs.setConfig({
    userSync: {
        userIds: [{
        name: 'merkleId',
        params: {
          vendor:'example_vendor',
          sv_cid:'example_cid',
          sv_pubid:'example_pubid',
          sv_domain:'example.com'
        },
        storage: {
          type: 'html5',
          name: 'merkleId',
          expires: 30
        }
      }]
    }
});

netID

The European netID Foundation (EnID) aims to establish with the netID an independent European alternative in the digital market for Demand and Supply side. With the netID Single-Sign-On, the EnID established an open standard for consumer logins for services of Buyers and Brands, that also includes user-centric consent management capabilities that results in a standardized, EU-GDPR compliant, IAB TCF aware, cross-device enabled Advertising Identifier, which can be leveraged by publishers and advertisers (and vendors supporting them) to efficiently deliver targeted advertising through programmatic systems to already more than 38 million Europeans on mobile and desktop devices.

The EnID is a non-profit organization which is open to any contributing party on both, the demand and supply side to make identity work for consumers as well as the advertising ecosystem.

netID Examples

1) Publisher stores netID via his own logic

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "netId",
            value: {
               "netId":"fH5A3n2O8_CZZyPoJVD-eabc6ECb7jhxCicsds7qSg"
            }
        }]
    }
});

NextRoll ID

NextRoll is an industry-leading marketing technology and data stack that fuels growth for businesses of all kinds. Our technology powers two multi-million dollar high-growth businesses: AdRoll and RollWorks. The NextRoll ID is a cookieless identifier built from NextRoll’s proprietary identity graph. Publishers, ad tech platforms, and NextRoll’s brands (AdRoll and RollWorks) leverage the NextRoll ID to access unique demand in cookieless environments. The NextRoll ID respects user privacy preferences and enables users to opt out through multiple web based mechanisms found in Section 8 of NextRoll’s Privacy Policy.

NextRoll ID Registration

To sign up for a Partner ID please contact your NextRoll representative or send an email to publishers@nextroll.com.

NextRoll ID Configuration

Add it to your Prebid.js package with:

gulp build –modules=nextrollIdSystem

Enable the module in configuration, with your Partner ID:

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "nextrollId",
            params: {
                partnerId: 'YOUR_PARTNER_ID'
            }
        }]
    }
});

Novatiq Snowflake ID

Novatiq proprietary dynamic snowflake ID is a unique, non sequential and single use identifier for marketing activation. Our in network solution matches verification requests to telco network IDs, safely and securely inside telecom infrastructure. Novatiq snowflake ID can be used for identity validation and as a secured 1st party data delivery mechanism.

Novatiq Snowflake ID Configuration

Enable by adding the Novatiq submodule to your Prebid.js package with:

gulp build --modules=novatiqIdSystem,userId

Module activation and configuration:

pbjs.setConfig({
  userSync: {
    userIds: [{
      name: 'novatiq',
      params: {
        sourceid '1a3',            // change to the Partner Number you received from Novatiq
        }
      }
    }],
    auctionDelay: 50             // 50ms maximum auction delay, applies to all userId modules
  }
});

If you have any questions, please reach out to us at prebid@novatiq.com.

Parrable ID

The Parrable ID is a Full Device Identifier that can be used to identify a device across different browsers and webviews on a single device including browsers that have third party cookie restrictions.

Add it to your Prebid.js package with:

gulp build –modules=parrableIdSystem

Parrable ID Registration

Please contact Parrable to obtain a Parrable Partner Client ID and/or use the Parrable Partner Client ID provided by the vendor for each Parrable-aware bid adapter you will be using. Note that if you are working with multiple Parrable-aware bid adapters you may use multiple Parrable Partner Client IDs.

The Parrable privacy policy as at https://www.parrable.com/privacy-policy/.

Parrable ID Configuration

In addition to the parameters documented above in the Basic Configuration section the following Parrable specific configuration is required:

NOTE: The Parrable ID that is delivered to Prebid is encrypted by Parrable with a time-based key and updated frequently in the browser to enforce consumer privacy requirements and thus will be different on every page view, even for the same user.

The Parrable ID system manages a cookie with the name of _parrable_id containing the ID and optout states of the user. This cookie is used also by standalone Parrable integrations outside of Prebid. It is for this reason that the cookie name is not configurable for the Parrable ID system.

Timezone and Timezone Offset Filtering

The Parrable ID system enables a publisher to configure lists of allowed timezones (eg. Europe/Dublin) and/or timezone offsets (eg. -4) as well as a lists of blocked timezones and timezone offsets.

• With no configuration (params.timezoneFilter not set, or all of the lists are empty) all impressions are permitted.
• With only allow lists configured a browser must match either a timezone or timezone offset for it to not be filtered.
• With only block lists configured an impression will be filtered only if it is from a browser matching a blocked timezone or timezone offset.
• An impression from a browser that matches any allowed timezone or timezone offset, but does not match a blocked timezone or timezone offset will engage in the Parrable ID syncronization process.
• If a browser has a stored Parrable ID then it will not be filtered even if the browser is in a timezone or timezone offset that is blocked.

All configured timezones should follow the TZ database name column from the IANA tz database

Parrable ID Examples

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: `'parrableId'`,
            params: {
              partners: [
                '30182847-e426-4ff9-b2b5-9ca1324ea09b',
                'b07cf20d-8b55-4cd7-9e84-d804ed66b644'
              ], // change to the Parrable Partner Client ID(s) you received from the Parrable Partners you are using
              timezoneFilter: {
                  allowedZones: ['America/New_York', 'Europe/Madrid']
              }
            }
        }],
        syncDelay: 1000
    }
});

RampID

RampID, formerly known as IdentityLink, provided by LiveRamp is a single person-based identifier which allows marketers, platforms and publishers to perform personalized segmentation, targeting and measurement use cases that require a consistent, cross-channel view of the user in anonymous spaces.

Add it to your Prebid.js package with:

gulp build –modules=identityLinkIdSystem

RampID Registration

Please sign up through our Console platform and request a placementId.

The RampID privacy policy is at https://liveramp.com/privacy/service-privacy-policy/.

RampID Configuration

RampID Examples

1) Publisher passes a placement ID and elects to store the RampID envelope in a cookie.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "identityLink",
            params: {
                pid: '999',             // Set your real RampID placement ID here
                // notUse3P: true/false    // If you do not want to use 3P endpoint to retrieve the envelope. If you do not set this property to true, 3P endpoint will be fired. By default this property is undefined and 3P request will be fired.
            },
            storage: {
                type: "cookie",
                name: "idl_env",       // create a cookie with this name
                expires: 30            // cookie can last for 30 days
            }
        }],
        syncDelay: 3000              // 3 seconds after the first auction
    }
});

2) Publisher passes a placement ID and elects to store the RampID envelope in HTML5 localStorage.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "identityLink",
            params: {
                pid: '999',          // Set your real RampID placement ID here
                // notUse3P: true/false    // If you do not want to use 3P endpoint to retrieve the envelope. If you do not set this property to true, 3P endpoint will be fired. By default this property is undefined and 3P request will be fired.
            },
            storage: {
                type: "html5",
                name: "idl_env",    // set localstorage with this name
                expires: 30
            }
        }],
        syncDelay: 3000
    }
});

SharedID

This module stores an unique user id in the first party domain and makes it accessible to all adapters. Similar to IDFA and AAID, this is a simple UUID that can be utilized to improve user matching, especially for iOS and MacOS browsers, and is compatible with ITP (Intelligent Tracking Prevention). It’s lightweight and self contained. Adapters that support SharedId will be able to pick up the user ID and return it for additional server-side cross device tracking.

There is no special registration or configuration for SharedID. Each publisher’s privacy policy should take SharedID into account. Prebid recommends implementing a method where users can easily opt-out of targeted advertising. Please refer to the User Opt-Out section located at the bottom of this page. For more information check out Prebid’s dedicated identity page

Add it to your Prebid.js package with:

gulp build –modules=pubCommonIdSystem

SharedID ID Configuration

In addition to the parameters documented above in the Basic Configuration section the following SharedID specific configuration is available:

SharedID Examples

1) Publisher supports SharedID and first party domain cookie storage

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "pubCommonId",
            storage: {
                type: "cookie",
                name: `"_pubcid"`,         // create a cookie with this name
                expires: 365             // expires in 1 years
            }
        }]
    }
});

2) Publisher supports both UnifiedID and SharedID and first party domain cookie storage

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "unifiedId",
            params: {
                partner: "myTtdPid"
            },
            storage: {
                type: "cookie",
                name: "pbjs-unifiedid",       // create a cookie with this name
                expires: 60
            }
        },{
            name: "pubCommonId",
            params: {
                pixelUrl: "/wp-json/pubcid/v1/extend/"
            },
            storage: {
                type: "cookie",
                name: `"_pubcid"`,      // create a cookie with this name
                expires: 180
            }
        }],
        syncDelay: 5000       // 5 seconds after the first bidRequest()
    }
});

3) Publisher supports SharedID and first party domain cookie storage initiated by a first party server

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "pubCommonId",
            params: {
                pixelUrl: "/wp-json/pubcid/v1/extend/" //pixelUrl should be specified when the server plugin is used
            },
            storage: {
                type: "cookie",
                name: `"_pubcid"`,         // create a cookie with this name
                expires: 365             // expires in 1 years
            }
        }]
    }
});

PubProvided ID

The PubProvided Id module allows publishers to set and pass a first party user id into the bid stream. This module has several unique characteristics:

1. The module supports a user defined function, that generates an eids-style object:

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "pubProvidedId",
            params: {
                eidsFunction: getIdsFn   // any function that exists in the page
            }
        }]
    }
});

Or, the eids values can be passed directly into the setConfig call:

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "pubProvidedId",
            params: {
                eids: [{
                    source: "domain.com",
                    uids: [{
                        id: "value read from cookie or local storage",
                        atype: 1,
                        ext: {
                            stype: "ppuid"
                        }

                    }]
                }, {
                    source: "3rdpartyprovided.com",
                    uids: [{
                        id: "value read from cookie or local storage",
                        atype: 3,
                        ext: {
                            stype: "dmp"
                        }
                    }]
                }]
            }
        }]
    }
});

In either case, bid adapters will receive the eid values after consent is validated.

1. This design allows for the setting of any number of uuids in the eids object. Publishers may work with multiple ID providers and nest their own id within the same eids object. The opportunity to link a 1st party uuid and a 3rd party generated UUID presents publishers with a unique ability to address their users in a way demand sources will understand.

2. Finally, this module allows publishers to broadcast their user id, derived from in-house tech, directly to buyers within the confines of existing compliance (CCPA & GDPR) frameworks.

3. The eids.uids.ext.stype “source-type” extension helps downstream entities know what do with the data. Currently defined values are:

• dmp - this uid comes from the in-page dmp named in eids.source
• ppuid - this uid comes from the publisher named in eids.source
• other - for setting other id origin signals please use the adCOM! atype spec

1. Bid adapters listening for “userIds.pubProvidedId” will not receive a string, please use the userIdAsEids value/function to return the userid as a string.

Add it to your Prebid.js package with:

gulp build –modules=pubProvidedId

PubProvided Configuration

Quantcast ID

The Prebid Quantcast ID module stores a Quantcast ID in a first party cookie. The ID is then made available in the bid request. The ID from the cookie added in the bidstream allows Quantcast to more accurately bid on publisher inventories without third party cookies, which can result in better monetization across publisher sites from Quantcast. And, it’s free to use! For easier integration, you can work with one of our SSP partners, like PubMatic, who can facilitate the legal process as well as the software integration for you.

Add it to your Prebid.js package with:

gulp build –modules=userId,quantcastIdSystem

Quantcast’s privacy policies for the services rendered can be found at https://www.quantcast.com/privacy/

Publishers deploying the module are responsible for ensuring legally required notices and choices for users.

The Quantcast ID module will only perform any action and return an ID in situations where:

1. the publisher has not set a ‘coppa’ flag on the prebid configuration on their site (see pbjs.setConfig.coppa)
2. there is not a IAB us-privacy string indicating the digital property has provided user notice and the user has made a choice to opt out of sale
3. if GDPR applies, an IAB TCF v2 string exists indicating that Quantcast does not have consent for purpose 1 (cookies, device identifiers, or other information can be stored or accessed on your device for the purposes presented to you), or an established legal basis (by default legitimate interest) for purpose 10 (your data can be used to improve existing systems and software, and to develop new products).

Quantcast ID Configuration

Quantcast ID Example

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "quantcastId"
        }]
    }
});

Tapad ID

Tapad’s ID module provides access to a universal identifier that publishers, ad tech platforms and advertisers can use for data collection and collation without reliance on third-party cookies. Tapad’s ID module is free to use and promotes collaboration across the industry by facilitating interoperability between DSPs, SSPs and publishers.

To register as an authorized user of the Tapad ID module, or for more information, documentation and access to Tapad’s Terms and Conditions please contact prebid@tapad.com.

Tapad’s Privacy landing page containing links to region-specific Privacy Notices may be found here: https://tapad.com/privacy.html.

Add it to your Prebid.js package with:

gulp build –modules=userId,tapadIdSystem

Tapad ID Configuration

Tapad ID Example

pbjs.setConfig({
    userSync: {
      userIds: [
        {
          name: "tapadId",
          params: {
            companyId: 1234567890
          },
          storage: {
            type: "cookie",
            name: "tapad_id",
            expires: 1
          }
        }
      ]
    }
});

Unified ID

The Unified ID solution is provided by adsrvr.org and the Trade Desk.

Add it to your Prebid.js package with:

gulp build –modules=unifiedIdSystem

Unified ID Registration

You can set up Unified ID in one of these ways:

• Register with The Trade Desk from their Unified ID page.
• Utilize a managed services company who can do this for you.

The Unified ID privacy is covered under the TradeDesk Services Privacy Policy.

Unified ID Configuration

Unified ID Examples

1) Publisher has a partner ID with The Trade Desk, and is using the default endpoint for Unified ID.

Bug: The default URL did not support HTTPS in Prebid.js 2.10-2.14. So instead of using the ‘partner’ parameter, it’s best to supply the Trade Desk URL as shown in this example.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "unifiedId",
            params: {
                url: "//match.adsrvr.org/track/rid?ttd_pid=MyTtidPid&fmt=json"
            },
            storage: {
                type: "cookie",
                name: "pbjs-unifiedid",       // create a cookie with this name
                expires: 60                   // cookie can last for 60 days
            }
        }],
        syncDelay: 3000              // 3 seconds after the first auction
    }
});

2) Publisher supports UnifiedID with a vendor other than Trade Desk and HTML5 local storage.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "unifiedId",
            params: {
                url: "URL_TO_UNIFIED_ID_SERVER"
            },
            storage: {
                type: "html5",
                name: "pbjs-unifiedid",    // set localstorage with this name
                expires: 60
            }
        }],
        syncDelay: 3000
    }
});

3) Publisher has integrated with UnifiedID on their own and wants to pass the UnifiedID directly through to Prebid.js.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "unifiedId",
            value: {"tdid": "D6885E90-2A7A-4E0F-87CB-7734ED1B99A3"}
        }]
    }
});

Unified ID 2.0

Unified ID 2 is an email based id solution that is owned and operated by the prebid community. Unified ID 2, relies on user consent before an id can be added to the bid stream. Consent can be gathered by SSO providers who have integrated against the UID 2 framework, or Publishers own login & consent mechaninism.

Add it to your Prebid.js package with:

gulp build –modules=uid2IdSystem

Unified ID Registration

You can set up Unified ID 2 in one of these ways:

• Include the module to your pb.js wrapper, no registration is required
• Utilize a managed services company who can do this for you.

Each publisher’s privacy policy should take UnifiedId 2 into account

Unified ID 2 Configuration

The below parameters apply only to the UID 2.0 User ID Module integration.

Unified ID 2 Example

Publisher has a integrated with an SSO provider that sets a cookie called __uid2_advertising_token when user consent is granted.

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: 'uid2'
        }]
    }
});

Verizon Media ConnectID

Verizon Media ConnectID is a person based ID and does not depend on 3rd party cookies. It enables ad tech platforms to recognize and match users consistently across the open web. Built on top of Verizon Media’s robust and proprietary ID Graph it delivers a higher find rate of audiences on publishers’ sites user targeting that respects privacy.

Verizon Media ConnectID honors privacy choices from the Verizon Media Privacy Dashboard as well as global privacy acts.

Add support for Verizon Media ConnectID to your Prebid.js package with:

gulp build –modules=userId,verizonMediaIdSystem

Verizon Media ConnectID Registration

A Verizon Media supplied publisher specific pixel Id is required. Reach out to your account manager for assistance with setup.

Verizon Media ConnectID Configuration

Verizon Media ConnectID Examples

pbjs.setConfig({
    userSync: {
        userIds: [{
            name: "verizonMediaId",
            params: {
              pixelId: 8976,
              he: "ed8ddbf5a171981db8ef938596ca297d5e3f84bcc280041c5880dba3baf9c1d4"
            },
            storage: {
              type: "html5",
              name: "connectid",
              expires: 1
            }
        }]
    }
})

Adapters Supporting the User ID Sub-Modules

Bidder Adapter Implementation

Prebid.js Adapters

Bidders that want to support the User ID module in Prebid.js, need to update their bidder adapter to read the indicated bidRequest attributes and pass them to their endpoint.

For example, the adapter code might do something like:

   if (bidRequest.userId && bidRequest.userId.sharedid) {
    url+="&pubcid="+bidRequest.userId.sharedid;
   }

Prebid Server Adapters

Bidders that want to support the User ID module in Prebid Server, need to update their server-side bid adapter to read the desired OpenRTB ‘user.ext.eids.source’ object and forward the relevant values to their endpoint.

See the Prebid.js EIDs javascript source for the definitive list of user EID sources.

Exporting User IDs

If you need to export the user IDs stored by Prebid User ID module, the getUserIds() function will return an object formatted the same as bidRequest.userId.

pbjs.getUserIds() // returns object like bidRequest.userId. e.g. {"pubcid":"1111", "tdid":"2222"}

You can use getUserIdsAsEids() to get the user IDs stored by Prebid User ID module in ORTB Eids format. Refer eids.md for output format.

pbjs.getUserIdsAsEids() // returns userIds in ORTB Eids format. e.g.
[
  {
      source: 'pubcid.org',
      uids: [{
          id: 'some-random-id-value',
          atype: 1
      }]
  },

  {
      source: 'adserver.org',
      uids: [{
          id: 'some-random-id-value',
          atype: 1,
          ext: {
              rtiPartner: 'TDID'
          }
      }]
  },

  {
      source: 'id5-sync.com',
      uids: [{
          id: 'ID5-12345',
          atype: 1,
          ext: {
              linkType: 2,
              abTestingControlGroup: false
          }
      }]
  }
]

ID Providers

If you’re an ID provider that wants to get on this page:

• Fork Prebid.js and write a sub-module similar to one of the *IdSystem modules already in the modules folder.
• Add your *IdSystem name into the modules/.submodules.json file
• Follow all the guidelines in the contribution page.
• Submit a Pull Request against the Prebid.js repository.
• Fork the prebid.org documentation repository, modify /dev-docs/modules/userId.md, /download.md, and submit a documentation Pull Request.

Passing UserIds to Google Ad Manager for targeting

User IDs from Prebid User ID module can be passed to GAM for targeting in Google Ad Manager or could be passed ahead to Google Open Bidding using userIdTargeting module. Note Google deprecated the ability to pass key values, including identifiers, to OB partners and then later began a closed beta to resume it with details non-public (see https://developers.google.com/authorized-buyers/rtb/request-guide ). More details on the user id module can be found here. In short, you just need to add the optional userIdTargeting sub-module into your gulp build command and the additional userIdTargeting config becomes available.

Further Reading

• Prebid.js Usersync
• GDPR ConsentManagement Module