prebid.js 7.3.0 → 7.6.0

package/modules/byDataAnalyticsAdapter.md

@@ -1,7 +1,7 @@
 # Overview
 
 layout: Analytics Adapter
-title: Ascendeum Pvt Ltd. (https://ascendeum.com/)
+title: byData. (https://bydata.com/)
 description: Bydata Analytics Adapter
 modulecode: byDataAnalyticsAdapter
 gdpr_supported: false   (EU GDPR support)
@@ -13,11 +13,12 @@ enable_download: false       (in case you don't want users of the website to dow
 
 Module Name: Bydata Analytics Adapter
 Module Type: Analytics Adapter
-Maintainer: Ascendeum
+Maintainer: byData
 
 # Description
 
-Analytics adapter for https://ascendeum.com/. Contact engineering@ascendeum.com for information.
+Analytics adapter for https://bydata.com/. Contact admin@byData.com for information.
+
 
 # Test Parameters
 
@@ -25,10 +26,8 @@ Analytics adapter for https://ascendeum.com/. Contact engineering@ascendeum.com
 {
   provider: 'bydata',
     options : {
-        clientId: "ASCENDEUM_PROVIDED_CLIENT_ID",   
+        clientId: "please contact byData team to get a clientId",   
         logFrequency : 100, // Sample Rate Default - 1%   
     }
 }
 ```
-
-

package/modules/consumableBidAdapter.js

@@ -1,4 +1,4 @@
-import { logWarn, createTrackPixelHtml } from '../src/utils.js';
+import { logWarn, createTrackPixelHtml, deepAccess, isArray, deepSetValue } from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 
 const BIDDER_CODE = 'consumable';
@@ -78,6 +78,8 @@ export const spec = {
       }
     });
 
+    handleEids(data, validBidRequests);
+
     ret.data = JSON.stringify(data);
     ret.bidRequest = validBidRequests;
     ret.bidderRequest = bidderRequest;
@@ -234,4 +236,13 @@ function retrieveAd(decision, unitId, unitName) {
   return ad;
 }
 
+function handleEids(data, validBidRequests) {
+  let bidUserIdAsEids = deepAccess(validBidRequests, '0.userIdAsEids');
+  if (isArray(bidUserIdAsEids) && bidUserIdAsEids.length > 0) {
+    deepSetValue(data, 'user.eids', bidUserIdAsEids);
+  } else {
+    deepSetValue(data, 'user.eids', undefined);
+  }
+}
+
 registerBidder(spec);

package/modules/criteoBidAdapter.js

@@ -13,7 +13,7 @@ const BIDDER_CODE = 'criteo';
 const CDB_ENDPOINT = 'https://bidder.criteo.com/cdb';
 const PROFILE_ID_INLINE = 207;
 export const PROFILE_ID_PUBLISHERTAG = 185;
-const storage = getStorageManager({ gvlid: GVLID, bidderCode: BIDDER_CODE });
+export const storage = getStorageManager({ gvlid: GVLID, bidderCode: BIDDER_CODE });
 const LOG_PREFIX = 'Criteo: ';
 
 /*
@@ -255,6 +255,12 @@ function buildCdbUrl(context) {
   url += '&wv=' + encodeURIComponent('$prebid.version$');
   url += '&cb=' + String(Math.floor(Math.random() * 99999999999));
 
+  if (storage.localStorageIsEnabled()) {
+    url += '&lsavail=1';
+  } else {
+    url += '&lsavail=0';
+  }
+
   if (context.amp) {
     url += '&im=1';
   }

package/modules/cwireBidAdapter.md

@@ -38,7 +38,7 @@ var adUnits = [
       params: {
         pageId: 1422,                 // required - number
         placementId: 2211521,         // required - number
-        cwcreative: 42,               // optional - id of creative to force
+        cwcreative: '42',             // optional - id of creative to force
         refgroups: 'test-user',       // optional - name of group or coma separated list of groups to force
         cwapikey: 'api_key_xyz',      // optional - api key for integration testing        
       }

package/modules/debugging/bidInterceptor.js

@@ -122,7 +122,7 @@ Object.assign(BidInterceptor.prototype, {
       replFn = () => ({});
     } else {
       replFn = ({args, ref = replDef}) => {
-        const result = {};
+        const result = Array.isArray(ref) ? [] : {};
         Object.entries(ref).forEach(([key, val]) => {
           if (typeof val === 'function') {
             result[key] = val(...args);

package/modules/debugging/index.js

@@ -3,5 +3,6 @@ import {hook} from '../../src/hook.js';
 import {install} from './debugging.js';
 import {prefixLog} from '../../src/utils.js';
 import {createBid} from '../../src/bidfactory.js';
+import {DEBUG_KEY} from '../../src/debugging.js';
 
-install({config, hook, createBid, logger: prefixLog('DEBUG:')});
+install({DEBUG_KEY, config, hook, createBid, logger: prefixLog('DEBUG:')});

package/modules/eplanningBidAdapter.js

@@ -1,4 +1,4 @@
-import {getWindowSelf, isEmpty, parseSizesInput} from '../src/utils.js';
+import {getWindowSelf, isEmpty, parseSizesInput, isGptPubadsDefined, isSlotMatchingAdUnitCode} from '../src/utils.js';
 import {getGlobal} from '../src/prebidGlobal.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {getStorageManager} from '../src/storageManager.js';
@@ -291,13 +291,25 @@ function getCharset() {
 
 function waitForElementsPresent(elements) {
   const observer = new MutationObserver(function (mutationList, observer) {
+    let index;
+    let adView;
     if (mutationList && Array.isArray(mutationList)) {
       mutationList.forEach(mr => {
         if (mr && mr.addedNodes && Array.isArray(mr.addedNodes)) {
           mr.addedNodes.forEach(ad => {
-            let index = elements.indexOf(ad.id);
+            index = elements.indexOf(ad.id);
+            adView = ad;
+            if (index < 0) {
+              elements.forEach(code => {
+                let div = _getAdSlotHTMLElement(code);
+                if (div && div.contains(ad) && div.getBoundingClientRect().width > 0) {
+                  index = elements.indexOf(div.id);
+                  adView = div;
+                }
+              });
+            }
             if (index >= 0) {
-              registerViewability(ad);
+              registerViewability(adView, elements[index]);
               elements.splice(index, 1);
               if (!elements.length) {
                 observer.disconnect();
@@ -318,19 +330,41 @@ function waitForElementsPresent(elements) {
   });
 }
 
-function registerViewability(div) {
+function registerViewability(div, name) {
   visibilityHandler({
-    name: div.id,
+    name: name,
     div: div
   });
 }
 
+function _mapAdUnitPathToElementId(adUnitCode) {
+  if (isGptPubadsDefined()) {
+    // eslint-disable-next-line no-undef
+    const adSlots = googletag.pubads().getSlots();
+    const isMatchingAdSlot = isSlotMatchingAdUnitCode(adUnitCode);
+
+    for (let i = 0; i < adSlots.length; i++) {
+      if (isMatchingAdSlot(adSlots[i])) {
+        const id = adSlots[i].getSlotElementId();
+        return id;
+      }
+    }
+  }
+
+  return null;
+}
+
+function _getAdSlotHTMLElement(adUnitCode) {
+  return document.getElementById(adUnitCode) ||
+    document.getElementById(_mapAdUnitPathToElementId(adUnitCode));
+}
+
 function registerViewabilityAllBids(bids) {
   let elementsNotPresent = [];
   bids.forEach(bid => {
-    let div = document.getElementById(bid.adUnitCode);
+    let div = _getAdSlotHTMLElement(bid.adUnitCode);
     if (div) {
-      registerViewability(div);
+      registerViewability(div, bid.adUnitCode);
     } else {
       elementsNotPresent.push(bid.adUnitCode);
     }
@@ -345,114 +379,65 @@ function getViewabilityTracker() {
   let VIEWABILITY_TIME = 1000;
   let VIEWABILITY_MIN_RATIO = 0.5;
   let publicApi;
-  let context;
-
-  function segmentIsOutsideTheVisibleRange(visibleRangeEnd, p1, p2) {
-    return p1 > visibleRangeEnd || p2 < 0;
-  }
-
-  function segmentBeginsBeforeTheVisibleRange(p1) {
-    return p1 < 0;
-  }
-
-  function segmentEndsAfterTheVisibleRange(visibleRangeEnd, p2) {
-    return p2 < visibleRangeEnd;
-  }
-
-  function axialVisibilityRatio(visibleRangeEnd, p1, p2) {
-    let visibilityRatio = 0;
-    if (!segmentIsOutsideTheVisibleRange(visibleRangeEnd, p1, p2)) {
-      if (segmentBeginsBeforeTheVisibleRange(p1)) {
-        visibilityRatio = p2 / (p2 - p1);
+  let observer;
+  let visibilityAds = {};
+
+  function intersectionCallback(entries) {
+    entries.forEach(function(entry) {
+      var adBox = entry.target;
+      if (entry.isIntersecting) {
+        if (entry.intersectionRatio >= VIEWABILITY_MIN_RATIO && entry.boundingClientRect && entry.boundingClientRect.height > 0 && entry.boundingClientRect.width > 0) {
+          visibilityAds[adBox.id] = true;
+        }
       } else {
-        visibilityRatio = segmentEndsAfterTheVisibleRange(visibleRangeEnd, p2) ? 1 : (visibleRangeEnd - p1) / (p2 - p1);
+        visibilityAds[adBox.id] = false;
       }
-    }
-    return visibilityRatio;
-  }
-
-  function isNotHiddenByNonFriendlyIframe() {
-    try { return (window === window.top) || window.frameElement; } catch (e) {}
-  }
-
-  function defineContext(e) {
-    try {
-      context = e && window.document.body.contains(e) ? window : (window.top.document.body.contains(e) ? top : undefined);
-    } catch (err) {}
-    return context;
-  }
-
-  function getContext(e) {
-    return context;
-  }
-
-  function verticalVisibilityRatio(position) {
-    return axialVisibilityRatio(getContext().innerHeight, position.top, position.bottom);
-  }
-
-  function horizontalVisibilityRatio(position) {
-    return axialVisibilityRatio(getContext().innerWidth, position.left, position.right);
-  }
-
-  function itIsNotHiddenByBannerAreaPosition(e) {
-    let position = e.getBoundingClientRect();
-    return (verticalVisibilityRatio(position) * horizontalVisibilityRatio(position)) > VIEWABILITY_MIN_RATIO;
-  }
-
-  function itIsNotHiddenByDisplayStyleCascade(e) {
-    return e.offsetHeight > 0 && e.offsetWidth > 0;
-  }
-
-  function itIsNotHiddenByOpacityStyleCascade(e) {
-    let s = e.style;
-    let p = e.parentNode;
-    return !(s && parseFloat(s.opacity) === 0) && (!p || itIsNotHiddenByOpacityStyleCascade(p));
-  }
-
-  function itIsNotHiddenByVisibilityStyleCascade(e) {
-    return getContext().getComputedStyle(e).visibility !== 'hidden';
-  }
-
-  function itIsNotHiddenByTabFocus() {
-    try { return getContext().top.document.hasFocus(); } catch (e) {}
-  }
-
-  function isDefined(e) {
-    return (e !== null) && (typeof e !== 'undefined');
+    });
   }
 
-  function itIsNotHiddenByOrphanBranch() {
-    return isDefined(getContext());
+  function observedElementIsVisible(element) {
+    return visibilityAds[element.id] && document.visibilityState && document.visibilityState === 'visible';
   }
 
-  function isContextInAnIframe() {
-    return isDefined(getContext().frameElement);
+  function defineObserver() {
+    if (!observer) {
+      var observerConfig = {
+        root: null,
+        rootMargin: '0px',
+        threshold: [VIEWABILITY_MIN_RATIO]
+      };
+      observer = new IntersectionObserver(intersectionCallback.bind(this), observerConfig);
+    }
   }
-
   function processIntervalVisibilityStatus(elapsedVisibleIntervals, element, callback) {
-    let visibleIntervals = isVisible(element) ? (elapsedVisibleIntervals + 1) : 0;
+    let visibleIntervals = observedElementIsVisible(element) ? (elapsedVisibleIntervals + 1) : 0;
     if (visibleIntervals === TIME_PARTITIONS) {
+      stopObserveViewability(element)
       callback();
     } else {
       setTimeout(processIntervalVisibilityStatus.bind(this, visibleIntervals, element, callback), VIEWABILITY_TIME / TIME_PARTITIONS);
     }
   }
 
-  function isVisible(element) {
-    defineContext(element);
-    return isNotHiddenByNonFriendlyIframe() &&
-      itIsNotHiddenByOrphanBranch() &&
-      itIsNotHiddenByTabFocus() &&
-      itIsNotHiddenByDisplayStyleCascade(element) &&
-      itIsNotHiddenByVisibilityStyleCascade(element) &&
-      itIsNotHiddenByOpacityStyleCascade(element) &&
-      itIsNotHiddenByBannerAreaPosition(element) &&
-      (!isContextInAnIframe() || isVisible(getContext().frameElement));
+  function stopObserveViewability(element) {
+    delete visibilityAds[element.id];
+    observer.unobserve(element);
+  }
+
+  function observeAds(element) {
+    observer.observe(element);
+  }
+
+  function initAndVerifyVisibility(element, callback) {
+    if (element) {
+      defineObserver();
+      observeAds(element);
+      processIntervalVisibilityStatus(0, element, callback);
+    }
   }
 
   publicApi = {
-    isVisible: isVisible,
-    onView: processIntervalVisibilityStatus.bind(this, 0)
+    onView: initAndVerifyVisibility.bind(this)
   };
 
   return publicApi;

package/modules/gdprEnforcement.js

@@ -18,8 +18,6 @@ const TCF2 = {
   'purpose7': { id: 7, name: 'measurement' }
 }
 
-const VENDORLESS_MODULE_TYPES = ['fpid-module'];
-
 /*
   These rules would be used if `consentManagement.gdpr.rules` is undefined by the publisher.
 */
@@ -125,10 +123,9 @@ function getGvlidForAnalyticsAdapter(code) {
  * @param {Object} consentData - gdpr consent data
  * @param {string=} currentModule - Bidder code of the current module
  * @param {number=} gvlId - GVL ID for the module
- * @param {string=} moduleType module type
  * @returns {boolean}
  */
-export function validateRules(rule, consentData, currentModule, gvlId, moduleType) {
+export function validateRules(rule, consentData, currentModule, gvlId) {
   const purposeId = TCF2[Object.keys(TCF2).filter(purposeName => TCF2[purposeName].name === rule.purpose)[0]].id;
 
   // return 'true' if vendor present in 'vendorExceptions'
@@ -141,14 +138,12 @@ export function validateRules(rule, consentData, currentModule, gvlId, moduleTyp
   const vendorConsent = deepAccess(consentData, `vendorData.vendor.consents.${gvlId}`);
   const liTransparency = deepAccess(consentData, `vendorData.purpose.legitimateInterests.${purposeId}`);
 
-  const vendorlessModule = includes(VENDORLESS_MODULE_TYPES, moduleType);
-
   /*
     Since vendor exceptions have already been handled, the purpose as a whole is allowed if it's not being enforced
     or the user has consented. Similar with vendors.
   */
   const purposeAllowed = rule.enforcePurpose === false || purposeConsent === true;
-  const vendorAllowed = rule.enforceVendor === false || vendorConsent === true || vendorlessModule === true;
+  const vendorAllowed = rule.enforceVendor === false || vendorConsent === true;
 
   /*
     Few if any vendors should be declaring Legitimate Interest for Device Access (Purpose 1), but some are claiming
@@ -167,16 +162,15 @@ export function validateRules(rule, consentData, currentModule, gvlId, moduleTyp
  * @param {Function} fn reference to original function (used by hook logic)
  * @param {Number=} gvlid gvlid of the module
  * @param {string=} moduleName name of the module
- * @param {string=} moduleType module type
  */
-export function deviceAccessHook(fn, gvlid, moduleName, moduleType, result) {
+export function deviceAccessHook(fn, gvlid, moduleName, result) {
   result = Object.assign({}, {
     hasEnforcementHook: true
   });
   if (!hasDeviceAccess()) {
     logWarn('Device access is disabled by Publisher');
     result.valid = false;
-    fn.call(this, gvlid, moduleName, moduleType, result);
+    fn.call(this, gvlid, moduleName, result);
   } else {
     const consentData = gdprDataHandler.getConsentData();
     if (consentData && consentData.gdprApplies) {
@@ -188,19 +182,19 @@ export function deviceAccessHook(fn, gvlid, moduleName, moduleType, result) {
         gvlid = getGvlid(moduleName) || gvlid;
       }
       const curModule = moduleName || curBidder;
-      let isAllowed = validateRules(purpose1Rule, consentData, curModule, gvlid, moduleType);
+      let isAllowed = validateRules(purpose1Rule, consentData, curModule, gvlid);
       if (isAllowed) {
         result.valid = true;
-        fn.call(this, gvlid, moduleName, moduleType, result);
+        fn.call(this, gvlid, moduleName, result);
       } else {
         curModule && logWarn(`TCF2 denied device access for ${curModule}`);
         result.valid = false;
         storageBlocked.push(curModule);
-        fn.call(this, gvlid, moduleName, moduleType, result);
+        fn.call(this, gvlid, moduleName, result);
       }
     } else {
       result.valid = true;
-      fn.call(this, gvlid, moduleName, moduleType, result);
+      fn.call(this, gvlid, moduleName, result);
     }
   }
 }

package/modules/gridNMBidAdapter.js

@@ -1,4 +1,13 @@
-import { isStr, deepAccess, isArray, isNumber, logError, logWarn, parseGPTSingleSizeArrayToRtbSize } from '../src/utils.js';
+import {
+  isStr,
+  deepAccess,
+  isArray,
+  isNumber,
+  logError,
+  logWarn,
+  parseGPTSingleSizeArrayToRtbSize,
+  mergeDeep
+} from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { Renderer } from '../src/Renderer.js';
 import { VIDEO } from '../src/mediaTypes.js';
@@ -153,9 +162,7 @@ export const spec = {
         user = {
           data: [{
             name: 'iow_labs_pub_data',
-            segment: jwpseg.map((seg) => {
-              return {name: 'jwpseg', value: seg};
-            })
+            segment: segmentProcessing(jwpseg, 'jwpseg'),
           }]
         };
       }
@@ -174,9 +181,27 @@ export const spec = {
         user.ext = userExt;
       }
 
+      const ortb2UserData = deepAccess(bidderRequest, 'ortb2.user.data');
+      if (ortb2UserData && ortb2UserData.length) {
+        if (!user) {
+          user = { data: [] };
+        }
+        user = mergeDeep(user, {
+          data: [...ortb2UserData]
+        });
+      }
+
       if (user) {
         request.user = user;
       }
+      const site = deepAccess(bidderRequest, 'ortb2.site');
+      if (site) {
+        const data = deepAccess(site, 'content.data');
+        if (data && data.length) {
+          const siteContent = request.site.content || {};
+          request.site.content = mergeDeep(siteContent, { data });
+        }
+      }
 
       if (gdprConsent && gdprConsent.gdprApplies) {
         request.regs = {
@@ -408,4 +433,20 @@ export function getSyncUrl() {
   return SYNC_URL;
 }
 
+function segmentProcessing(segment, forceSegName) {
+  return segment
+    .map((seg) => {
+      const value = seg && (seg.value || seg.id || seg);
+      if (typeof value === 'string' || typeof value === 'number') {
+        return {
+          value: value.toString(),
+          ...(forceSegName && { name: forceSegName }),
+          ...(seg.name && { name: seg.name }),
+        };
+      }
+      return null;
+    })
+    .filter((seg) => !!seg);
+}
+
 registerBidder(spec);

package/modules/hadronAnalyticsAdapter.md

@@ -33,7 +33,7 @@ The following configuration parameters are available:
 
 ```javascript
 pbjs.enableAnalytics({
-    provider: 'hadron',
+    provider: 'hadronAnalytics',
     options: {
         partnerId: 1234, // change to the Partner ID you got from Audigent
         eventsToTrack: ['auctionEnd','bidWon']
@@ -41,8 +41,8 @@ pbjs.enableAnalytics({
 });
 ```
 
-| Parameter | Scope | Type | Description                                             | Example |
-| --- | --- | --- |---------------------------------------------------------| --- |
-| provider | Required | String | The name of this module: `hadronAnalytics`              | `hadronAnalytics` |
-| options.partnerId | Required | Number | This is the Audigent Partner ID obtained from Audigent. | `1234` |
+| Parameter             | Scope    | Type             | Description                                             | Example                   |
+|-----------------------|----------|------------------|---------------------------------------------------------|---------------------------|
+| provider              | Required | String           | The name of this module: `hadronAnalytics`              | `hadronAnalytics`         |
+| options.partnerId     | Required | Number           | This is the Audigent Partner ID obtained from Audigent. | `1234`                    |
 | options.eventsToTrack | Optional | Array of strings | Overrides the set of tracked events                     | `['auctionEnd','bidWon']` |

package/modules/hadronIdSystem.js

@@ -12,6 +12,7 @@ import { isFn, isStr, isPlainObject, logError } from '../src/utils.js';
 
 const MODULE_NAME = 'hadronId';
 const AU_GVLID = 561;
+const DEFAULT_HADRON_URL_ENDPOINT = 'https://id.hadron.ad.gt/api/v1/pbhid';
 
 export const storage = getStorageManager({gvlid: AU_GVLID, moduleName: 'hadron'});
 
@@ -29,6 +30,15 @@ function paramOrDefault(param, defaultVal, arg) {
   return defaultVal;
 }
 
+/**
+ * @param {string} url
+ * @param {string} params
+ * @returns {string}
+ */
+const urlAddParams = (url, params) => {
+  return url + (url.indexOf('?') > -1 ? '&' : '?') + params
+}
+
 /** @type {Submodule} */
 export const hadronIdSubmodule = {
   /**
@@ -39,8 +49,8 @@ export const hadronIdSubmodule = {
   /**
    * decode the stored id value for passing to bid requests
    * @function
-   * @param {{value:string}} value
-   * @returns {{hadronId:Object}}
+   * @param {string} value
+   * @returns {Object}
    */
   decode(value) {
     let hadronId = storage.getDataFromLocalStorage('auHadronId');
@@ -59,9 +69,12 @@ export const hadronIdSubmodule = {
     if (!isPlainObject(config.params)) {
       config.params = {};
     }
-    const url = paramOrDefault(config.params.url,
-      `https://id.hadron.ad.gt/api/v1/pbhid`,
-      config.params.urlArg);
+    const partnerId = config.params.partnerId | 0;
+
+    const url = urlAddParams(
+      paramOrDefault(config.params.url, DEFAULT_HADRON_URL_ENDPOINT, config.params.urlArg),
+      `partner_id=${partnerId}&_it=prebid`
+    );
 
     const resp = function (callback) {
       let hadronId = storage.getDataFromLocalStorage('auHadronId');

package/modules/hadronIdSystem.md

@@ -11,6 +11,9 @@ pbjs.setConfig({
     usersync: {
         userIds: [{
             name: 'hadronId',
+            params: {
+                partnerId: 1234   // change it to the Partner ID you'll get from Audigent
+            },
             storage: {
                 name: 'hadronId',
                 type: 'html5'
@@ -22,14 +25,15 @@ pbjs.setConfig({
 ## Parameter Descriptions for the `usersync` Configuration Section
 The below parameters apply only to the HadronID User ID Module integration.
 
-| Param under usersync.userIds[] | Scope | Type | Description | Example |
-| --- | --- | --- | --- | --- |
-| name | Required | String | ID value for the HadronID module - `"hadronId"` | `"hadronId"` |
-| storage | Required | Object | The publisher must specify the local storage in which to store the results of the call to get the user ID. This can be either cookie or HTML5 storage. | |
-| storage.type | Required | String | This is where the results of the user ID will be stored. The recommended method is `localStorage` by specifying `html5`. | `"html5"` |
-| storage.name | Required | String | The name of the cookie or html5 local storage where the user ID will be stored. | `"hadronid"` |
-| storage.expires | Optional | Integer | How long (in days) the user ID information will be stored. | `365` |
-| value | Optional | Object | Used only if the page has a separate mechanism for storing the Hadron ID. The value is an object containing the values to be sent to the adapters. In this scenario, no URL is called and nothing is added to local storage | `{"hadronId": "eb33b0cb-8d35-4722-b9c0-1a31d4064888"}` |
-| params | Optional | Object | Used to store params for the id system |
-| params.url | Optional | String | Set an alternate GET url for HadronId with this parameter |
-| params.urlArg | Optional | Object | Optional url parameter for params.url |
+| Param under usersync.userIds[] | Scope    | Type    | Description                                                                                                                                                                                                                 | Example                                                |
+|--------------------------------|----------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------|
+| name                           | Required | String  | ID value for the HadronID module - `"hadronId"`                                                                                                                                                                             | `"hadronId"`                                           |
+| storage                        | Required | Object  | The publisher must specify the local storage in which to store the results of the call to get the user ID. This can be either cookie or HTML5 storage.                                                                      |                                                        |
+| storage.type                   | Required | String  | This is where the results of the user ID will be stored. The recommended method is `localStorage` by specifying `html5`.                                                                                                    | `"html5"`                                              |
+| storage.name                   | Required | String  | The name of the cookie or html5 local storage where the user ID will be stored.                                                                                                                                             | `"hadronid"`                                           |
+| storage.expires                | Optional | Integer | How long (in days) the user ID information will be stored.                                                                                                                                                                  | `365`                                                  |
+| value                          | Optional | Object  | Used only if the page has a separate mechanism for storing the Hadron ID. The value is an object containing the values to be sent to the adapters. In this scenario, no URL is called and nothing is added to local storage | `{"hadronId": "eb33b0cb-8d35-4722-b9c0-1a31d4064888"}` |
+| params                         | Optional | Object  | Used to store params for the id system                                                                                                                                                                                      |
+| params.partnerId               | Required | Number  | This is the Audigent Partner ID obtained from Audigent.                                                                                                                                                                     | `1234`                                                 |
+| params.url                     | Optional | String  | Set an alternate GET url for HadronId with this parameter                                                                                                                                                                   |
+| params.urlArg                  | Optional | Object  | Optional url parameter for params.url                                                                                                                                                                                       |

package/modules/hadronRtdProvider.js

@@ -23,6 +23,15 @@ export const HALOID_LOCAL_NAME = 'auHadronId';
 export const RTD_LOCAL_NAME = 'auHadronRtd';
 export const storage = getStorageManager({gvlid: AU_GVLID, moduleName: SUBMODULE_NAME});
 
+/**
+ * @param {string} url
+ * @param {string} params
+ * @returns {string}
+ */
+const urlAddParams = (url, params) => {
+  return url + (url.indexOf('?') > -1 ? '&' : '?') + params
+}
+
 /**
  * Deep set an object unless value present.
  * @param {Object} obj
@@ -165,8 +174,12 @@ export function getRealTimeData(bidConfig, onDone, rtdConfig, userConsent) {
       userIds.hadronId = hadronId;
       getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds);
     }
+    const partnerId = rtdConfig.params.partnerId | 0;
     const hadronIdUrl = rtdConfig.params && rtdConfig.params.hadronIdUrl;
-    const scriptUrl = paramOrDefault(hadronIdUrl, HADRON_ID_DEFAULT_URL, userIds);
+    const scriptUrl = urlAddParams(
+      paramOrDefault(hadronIdUrl, HADRON_ID_DEFAULT_URL, userIds),
+      `partner_id=${partnerId}&_it=prebid`
+    );
     loadExternalScript(scriptUrl, 'hadron', () => {
       logInfo(LOG_PREFIX, 'hadronIdTag loaded', scriptUrl);
     })