Index Exchange
Features
Bidder Code | ix | Prebid.org Member | yes |
---|---|---|---|
Prebid.js Adapter | yes | Prebid Server Adapter | no |
Media Types | display, video, native | Multi Format Support | true |
TCF-EU Support | yes | IAB GVL ID | 10 |
GPP Support | some (check with bidder) | DSA Support | yes |
USP/CCPA Support | yes | COPPA Support | yes |
Supply Chain Support | yes | Demand Chain Support | no |
Safeframes OK | yes | Supports Deals | yes |
Floors Module Support | yes | First Party Data Support | yes |
User IDs | amazonAdvertisingID, fabrickId, zeotapIdPlus, TDID, tpid, id5Id, lotamePanoramaId, publinkId, hadronId, pubcid, trustpid, utiqMtpId, criteoID, euid, imuid, 33acrossId, nonID, pairId, M1ID, RampID, connectId | ORTB Blocking Support | check with bidder |
Privacy Sandbox | paapi, topics |
Table of contents
- Table of contents
- Introduction
- Supported media types
- Set up Prebid.js to call Index directly from the browser
- Set up Prebid.js to call Index through Prebid Server
- Modules to include in your build process
- Set up First Party Data (FPD)
- Monetize instream video
- Index’s outstream ad unit
- Prebid Native configuration
- Protected Audience API support
- Signal inventory using external IDs
- Bid request parameters
- Multi-format ad units
- Examples
Introduction
Publishers can use Prebid.js to call Index Exchange (Index) in any of the following ways:
- Call through our client-side adapter: Prebid.js calls Index directly from the browser using our client-side adapter. This option tends to have a better cookie match rate. For configuration instructions, see the Set up Prebid.js to call Index directly from the browser (client-side adapter) on this page.
- Call through our server-side adapter: Prebid.js makes a call to Prebid Server and then Prebid Server uses our server-side adapter to call Index. This reduces workload on the browser. For configuration instructions, see the Set up Prebid.js to call Index through Prebid Server (server-side adapter) on this page.
Notes:
- Send multiple ad slots in a single bid request: Index accepts up to 100 valid ad slots in a single bid request. If a single bid request contains more than 100 ad slots (including invalid ad slots), only the first 100 valid ad slots are accepted and the rest are ignored. For example streaming TV media owners can signal multiple ad pods for long-form programming in a single request.
- How to view bid requests sent to Index:
- In your browser, open a new tab.
- Open the Developer tools.
- In Developer tools, click the Network tab.
- In the Network tab, search for requests sent to
casalemedia.com/cygnus
(from version 6.28.0 and earlier) orcasalemedia.com/openrtb/pbjs
(from version 6.29.0 and later). These are the bid requests sent to Index.
- Recommended Global Bidder settings: For our adapter, Index recommends enabling local storage. As of Prebid.js 7.x, local storage access must be explicitly specified. By leveraging local storage, Index is able to take advantage of the latest features our exchange has to offer. For instructions on enabling local storage, see Prebid’s pbjs.bidderSettings documentation.
Example
pbjs.bidderSettings = {
ix: {
storageAllowed: true
}
};
Supported media types
The following table lists the media types that Index supports. For information about the the Time-To-Live (TTL) for each media type, see How Index counts impressions in our Knowledge Base.
Type | Prebid Server support |
---|---|
banner | Supported |
video | Supported |
native | Supported |
Set up Prebid.js to call Index directly from the browser (client-side adapter)
To call Index from a web browser environment using a Prebid Server integration, see the Index-specific configuration steps in Setup instructions to call Index through Prebid Server in our Prebid Server documentation on the Prebid site.
Set up Prebid.js to call Index through Prebid Server (server-side adapter)
In this configuration, Prebid.js makes a call to Prebid Server and then Prebid Server uses our server-side adapter to call Index. Complete the following steps to configure Index as a demand source:
- If you are hosting your own Prebid Server instance, see Setup instructions to call Index through Prebid Server.
- In the
[pbjs.setConfig()]
function, within thes2sConfig
property, addix
to thebidders
attribute. - Define the Index-specific parameters at the bidder level. For Index’s bidder-specific parameters, see the Bid request parameters section below.
- Define your ad units in the
adUnit
object. For more information about this object, see Prebid’s Ad Unit Reference documentation. -
Enable user syncing by adding the following code in the pbjs.setConfig() function. Index strongly recommends enabling user syncing through iFrames, though we do also support image-based syncing. This functionality improves DSP user match rates and increases the Index bid rate and bid price. Be sure to call
pbjs.setConfig()
only once. This configuration is optional in Prebid, but required by Index.pbjs.setConfig({ userSync: { iframeEnabled: true, filterSettings: { iframe: { bidders: ['ix'], filter: 'include' } } } });
- (Optional) Set up First Party Data (FPD). For more information about the data types we support and the instructions for each option, see the Set up First Party Data (FPD) section below.
- (Optional) If you want to monetize instream video, see the Monetize instream video section below.
- (Optional) If you want to monetize outstream video, you can choose among the following options:
- Use Index’s outstream video player. For more information, see the Index’s outstream ad unit section below.
- Use your own outstream video player. For more information, see Prebid’s documentation on how to show video ads.
- (Optional) Configure Prebid Native with Index. For more information, see the Prebid Native section below. Prebid Native is available from Prebid.js version 7.4.0 or higher.
Modules to include in your build process
If you are building the JS binary on your own from source code, follow the instructions in Prebid.js project README. You will need to include the ixBidAdapter
. If you want to show video ads with Google Ad Manager, also include the dfpAdServerVideo
module. We highly recommend adding the gptPreAuction
module as well, which improves a DSP’s ability to bid accurately on your supply. The following is an example build command that include these modules:
gulp build --modules=ixBidAdapter,dfpAdServerVideo,gptPreAuction,fooBidAdapter,bazBidAdapter
If you are using a JSON file to specify modules, add ixBidAdapter
and dfpAdServerVideo
to the modules array as follows:
[
"ixBidAdapter",
"dfpAdServerVideo",
"gptPreAuction",
"fooBidAdapter",
"bazBidAdapter"
]
Set up First Party Data (FPD)
You can set up the Prebid.js FPD module using Global data, Index bidder-specific site data, or ad unit-specific data. Index supports deal targeting in all the three FPD types.
Global data
Use this data type to allow all bid adapters to have access to first party data that might be useful in ad targeting. This is available from Prebid.js version 4.30 and above.
To supply data that is accessible to all bidders, use the [pbjs.setConfig()]
object as illustrated below. Use the [setBidderConfig()]
function to supply bidder-specific data. For more information about the standard or more detailed examples, see Prebid’s First Party Data Feature documentation.
pbjs.setConfig({
ortb2: {
site: {
...
},
user: {
...
}
}
});
Index bidder-specific data
This data type is available from Prebid version 7.49.0 and above. You can use it to specify key-value pairs that will be included in your query string when targeting deals. For example, if a user visits a news page, you can pass that information by submitting a key-value pair for category = news
. You can then create a deal in the Index UI and activate the deal only on pages that contain category = news
as the key-value pair.
To include the FPD in a bid request, in the [pbjs.setConfig()]
object at the ix
bidder level, provide the key-values in the firstPartyData
parameter. Make sure that you set it before the pbjs.requestBids
configuration. If you want to change the values, you can update the pbjs.setConfig
once again. The change will be reflected in all future bid requests.
pbjs.setConfig({
ix: {
firstPartyData: {
'<key name>': '<key value>',
'<key name>': '<key value>',
// ...
}
}
});
AdUnit-specific data
Use this data type to specify key-value pairs at the ad unit level when targeting deals and apply it to all bidders. This will be available from Prebid.js version 7.46 and above. To include the adUnit-specific data in a bid request, see Prebid’s Supplying AdUnit-Specific Data documentation.
ortb2Imp: {
ext: {
data: {
pbadslot: "homepage-top-rect",
adUnitSpecificAttribute: "123"
}
}
}
Monetize instream video
Unlike Outstream Video, instream video does not use the Prebid Universal Creative. Instead, video bids provide VAST that Prebid caches to obtain a cache ID that can be retrieved with a URL. The cache ID is passed as a key value to the ad server.
To monetize instream video, complete the following steps:
-
Enable a cache endpoint in the
[pbjs.setConfig()]
function as follows:pbjs.setConfig({ cache: { url: 'https://prebid.adnxs.com/pbc/v1/cache' } });
-
Set up your line items in Google Ad manger by following the instructions in Prebid’s Setting Up Video In GAM documentation.
Index’s outstream ad unit
Publishers who are using Index as a bidding adapter in Prebid.js can show outstream video ads on their site using Index’s outstream ad unit. This allows a video ad to be placed anywhere on a publisher’s site, such as in-article, in-feed, and more. To use Index’s outstream ad unit, you must be on Prebid.js version 5.13 or higher. However, if you are using your own outstream video player, Index’s adapter can accept video signals from version 2.41.0 or higher.
Note: When you use the Index ad unit for outstream video, all impressions are considered viewable, which is similar to how Google’s ActiveView counts impressions for outstream. This is because Index plays the outstream video as soon as it is in view and concurrently fires any impression pixels in the VAST.
To use Index’s outstream ad unit, in your Prebid.js configuration:
- Perform the following steps in your Prebid.js configuration to create a new section for Index’s outstream ad unit:
- Add a new code property under
adUnits
. The code could be thedivID
or the Google Ad Manager adUnit code. - Within the
adUnits
, addix
as abidder
. - At the
adUnit
level, undermediaTypes
, you must add avideo
object that supports our required video parameters. For more information about which parameters to add, see the Bid request parameters section below. This is useful for publishers who want to apply the same settings across all SSPs. - Optionally, you can add the
video
object at the bidder level underbids.params
. This is useful for publishers who may want to set up different configurations for different SSPs.
Note: Thebidder
level video configurations override theadUnit
level configurations. TheplayerConfig
is only a bidder level configuration.
- Add a new code property under
- (Recommended) To force the Index ad unit as the default player for Index, set
backupOnly
to true (see below example). This configuration allows you to use your own player only when an adapter does not provide their own player. This also forces any adapter that has a player to use their player by default. If no player is provided, by default, we will use our own ad unit script. - Configure the ad unit according to the options in the Bid request parameters section below.
- Depending on your existing Prebid setup, complete one of the following:
- If you have an existing Prebid.js integration for banner, you can use the corresponding line items in your Google Ad Manager (GAM) account to retrieve outstream video demand. For more information, see Prebid’s documentation on How to set up line items.
- If you do not have an existing Prebid.js integration for banner, create a line item in your GAM account that is capable of serving an outstream video ad. For more information about how to do this, see Prebid’s documentation on Setting up Prebid Video in Google Ad Manager.
- Notify your Index Representative and provide your test page URL for validation. They will work with you to test the video ad unit and confirm that outstream video ads are being retrieved.
For more information on how to structure the video object, refer to the following code example:
pbjs.addAdUnit({
code: 'video1',
// This video player would apply to all prebid creatives...
renderer: {
url: 'example.com/publishersCustomRenderer.js',
backupOnly: true,
render: function (bid) { renderAdUnit(...) }
},
mediaTypes: {
// Publisher video player video settings...
video: {
context: 'outstream',
playerSize: [640, 480],
mimes: ['video/mp4'],
protocols: [1, 2, 3, 4, 5, 6, 7, 8],
placement: 3,
playbackmethod: [6],
skip: 1,
plcmt: 4
}
},
bids: [{
bidder: 'ix',
params: {
siteId: '9999990',
// Index ad unit video settings...
video: {
//minimum size for Video Player size is 144x144 in pixel
//maxduration can be any.
context: 'outstream',
playerSize: [640, 480],
mimes: ['video/mp4', 'video/webm', 'applications/javascript'],
protocols: [2, 3, 5, 6],
api: [2, 7],
playbackmethod: [6],
skip: 1,
w: 640,
h: 480,
minduration: 5,
maxduration: 60,
delivery: [2],
linearity: 1
}
}
}]
});
Please note that your use of the outstream video player will be governed by and subject to the terms and conditions of i) any master services or license agreement entered into by you and Index Exchange; ii) the information provided on our knowledge base linked here and here, and iii) our Privacy Policy. Your use of Index’s outstream video player constitutes your acknowledgement and acceptance of the foregoing.
Prebid Native configuration
Prebid Native is available from Prebid.js version 7.4.0 or higher. We support the three native template rendering options that are provided in Setting up Prebid Native in Google Ad Manager. The following code is an example of a Prebid native setup using Google Ad Manager, but the concept and implementation should be similar for other ad servers.
pbjs.addAdUnits({
code: slot.code,
mediaTypes: {
native: {
ortb: {
assets: [{
id: 1,
required: 1,
img: {
type: 3,
w: 150,
h: 50,
}
},
{
id: 2,
required: 1,
title: {
len: 80
}
},
{
id: 3,
required: 1,
data: {
type: 1
}
},
{
id: 4,
required: 1,
data: {
type: 2
}
},
{
id: 6,
required: 1,
img: {
type: 1,
w: 50,
h: 50,
}
}]
}
}
},
bids: [{
bidder: 'ix',
params: {
siteId: '9999990'
}
}]
});
Protected Audience API support
Before you begin:
- You must have Google Ad Manager and the paapiForGpt module.
- In your Google Ad Manager configuration, make sure that you have not opted out from using the Protected Audience API. For more information about the configuration, see Google’s documentation on Protected Audience API and Ad Manager after Chrome GA.
Depending on the Prebid.js version that you are using, the steps to configure Prebid.js will differ. Follow the steps provided in the appropriate section for the version of Prebid.js that you are using:
Configure Protected Audience API for Prebid.js versions 8.18.0 to 8.36.0
- Build the
paapiForGpt
module in your Prebid.js configuration by addingfledgeForGpt
to the list of modules that you are already using. For more information about the module, see Prebid’s Protected Audience API (PAAPI) for GPT Module documentation. -
Configure your ad units to make them eligible for Protected Audience API demand. You can do this in the global-level configuration, bidder level, or ad-unit level. For more information about the configurations, see Prebid’s Protected Audience API (PAAPI) for GPT Module documentation. Index recommends that you do this in the global-level configuration by using the
defaultForSlots
parameter with a value of1
. The following code is an example of the configuration done at the global level:pbjs.que.push(function() { pbjs.setConfig({ paapi: { enabled: true, defaultForSlots: 1 } }); });
Note: If you are using the
paapiForGpt.bidders[]
, make sure that you includeix
to the list of bidders as follows:pbjs.que.push(function() { pbjs.setConfig({ paapi: { enabled: true, bidders: ['ix', /* any other bidders */], defaultForSlots: 1 } }); });
Configure Protected Audience API for Prebid.js versions 8.37.0 and up to 9.0.0
- Build the
fledgeForGpt
module in your Prebid.js configuration by addingfledgeForGpt
to the list of modules that you are already using. For more information about the module, see Prebid’s Protected Audience API (PAAPI) for GPT Module documentation. - Complete the following steps to make your ad units eligible for Protected Audience API demand:
Note: If you continue to use thefledgeForGpt
property, you will receive a warning message in the console logs stating that thefledgeForGpt
configuration options will soon be renamed topaapi
. Therefore, Index recommends that you use thepaapi
property, which is available in Prebid.js version 8.37.0 or later.- In the
pbjs.setConfig().paapi
field, set thedefaultForSlots
parameter to1
:
pbjs.que.push(function() { pbjs.setConfig({ fledgeForGpt: { enabled: true, defaultForSlots: 1, bidders: ['ix', /* any other bidders */], }); });
- In the
paapi.gpt.autoconfig
field, setautoconfig
tofalse
. This step is important because, by default, thepaapiForGpt
module expects the Google Publisher Tag (GPT) ad units to be loaded before the Protected Audience configuration is added to the ad unit. Settingautoconfig
tofalse
will avoid any race conditions resulting from asynchronous libraries being loaded out of order, which would prevent the ad unit from being properly configured for Protected Audience API.
Note: ThepaapiForGpt.autoconfig
property is also backward compatible and can be used in place of thepaapi.gpt.autoconfig
property. However, Index recommends that you use thepaapi.gpt.autoconfig
property.
pbjs.que.push(function() { pbjs.setConfig({ paapi: { enabled: true, defaultForSlots: 1 gpt: { autoconfig: false }, bidders: ['ix', /* any other bidders */], }); });
- In the
pbjs.requestBids.bidsBackHandler
function, call thepbjs.setPAAPIConfigForGPT()
function as follows:
Note: When calling thepbjs.setPAAPIConfigForGPT();
function, make sure that you check the following:- The function must be called in the
bidsBackHandler
each time new bids are requested (for example when refreshingadSlots
). This is important because, whenautoconfig
is disabled, theauctionConfig
needs to be associated with a GPT ad unit manually by callingpbjs.setPAAPIConfigForGPT()
. - The function must be called before the
pbjs.setTargetingForGPTAsync()
function. This is important because the Protected Audience configuration needs to be associated with a GPT ad unit before the Google Ad Manager call is executed.
- The function must be called in the
pbjs.requestBids({, , // ... bidsBackHandler: function(bids, timedOut, auctionId) { pbjs.setPAAPIConfigForGPT(); pbjs.setTargetingForGPTAsync(); // ... } })
- In the
Configure Protected Audience API for Prebid.js version 9.0.0 or later
- Build the PAAPI module in your Prebid.js configuration by adding paapi to the list of modules that you are already using. For more information about the module, see Prebid’s [Protected Audience API (PAAPI) for GPT Module(/dev-docs/modules/fledgeForGpt.html) documentation.
- In the
pbjs.setConfig().paapi
field, set thedefaultForSlots
parameter to1
. - In the
paapi.gpt.configWithTargeting
field, setconfigWithTargeting
totrue
. For more control over configuring GPT slots to use PAAPI, set theconfigWithTargeting
tofalse
and use thesetPAAPIConfigForGPT
API. For more information about the configurations, see Prebid’s Prebid’s [Protected Audience API (PAAPI) for GPT Module(/dev-docs/modules/fledgeForGpt.html) documentation.
The following code is an example of thedefaultForSlots
andconfigWithTargeting
configuration:
pbjs.que.push(function() {
pbjs.setConfig({
paapi: {
enabled: true,
defaultForSlots: 1
gpt: {
configWithTargeting: true
},
bidders: ['ix', /* any other bidders */],
});
});
Signal inventory using external IDs
-
In the
pbjs.setBidderConfig
object at theix
bidder level, you must configure anexchangeId
that applies to all your placements as follows. Note that theexchangeId
is provided by Index.pbjs.setBidderConfig({ bidders: ['ix'], config: { exchangeId: 123456 // Exchange-specific seller ID } });
-
Configure
externalId
at the bidder ad unit level underbids.params
. The following shows an example of a banner ad that includes theexternalId
at the bidder level:
// Banner
var adUnits = [{
code: 'banner-div-a',
mediaTypes: {
banner: {
sizes: [
[300, 250],
[300, 600]
]
}
},
bids: [{
bidder: 'ix',
params: {
externalId: "example_value" // External placement ID, which could include an integer or string
}
}
]
}];
Bid request parameters
For a list of the OpenRTB fields that Index supports in bid requests, see List of supported OpenRTB bid request fields for sellers. The following are the required fields for the various supported media types.
Banner
You must include these parameters at the bidder level.
Name | Scope | Type | Description |
---|---|---|---|
siteId |
Required | String | An Index-specific identifier that is associated with this ad unit. This is similar to a placement ID or an ad unit ID that some other modules have. For example, '9999990' , '9999991' , '9999992' |
Video
You must include these parameters at the bidder level.
Name | Scope | Type | Description |
---|---|---|---|
siteId |
Required | String | An Index-specific identifier that is associated with this ad unit. It will be associated with the single size, if the size is provided. This is similar to a placement ID or an ad unit ID that some other modules have. For example, '9999990' , '9999991' , '9999992' Note: You can re-use the existing siteId within the same flex position or video size, if the video adapts to the containing <div> element. |
If you are using Index’s outstream ad unit and have placed the video object at the bidder level, you must include the Index required parameters at the bidder level. You can include the optional parameters to specify the outstream player configurations.
Name | Scope | Type | Description |
---|---|---|---|
video.w |
Required | Integer | The width of the video player in pixels that will be passed to demand partners. You must define the size of the video player using the video.w and video.h parameters. We strongly recommend video sizes to be 256 x 256 or greater, 300 x 250 , or 320 x 180 . |
video.h |
Required | Integer | The height of the video player in pixels that will be passed to demand partners. You must define the size of the video player using the video.w and video.h parameters. We strongly recommend video sizes to be 256 x 256 or greater, 300 x 250 , or 320 x 180 . |
video.playerSize |
Required | Integer[] | The video player size that will be passed to demand partners. |
video.playerConfig |
Optional | Hash | The Index-specific outstream player configurations. |
video.playerConfig.floatOnScroll |
Optional | Boolean | A boolean specifying whether you want to use the player’s floating capabilities, where: - true : Use the Index player’s float capabilities.Note: If you set floatOnScroll to true , Index updates the placement value to 5 .Note: We do not recommend using the player’s default float capabilities if you have more than one outstream ad unit per page. - false : Do not use the Index player’s float capabilities (default). |
video.playerConfig.floatSize |
Optional | Integer[] | The height and width of the floating player in pixels. If you do not specify a float size, the player adjusts to the aspect ratio of the player size that is defined when it is not floating. Index recommends that you review and test the float size to your user experience preference. |
video.plcmt |
Required | Integer[] | The video’s placement type, where: - 1 = Instream- 2 = Accompanying Content - 3 = Interstitial - 4 = No Content/Standalone |
Native
Index supports the same set of native assets that Prebid.js recognizes. For the list of native assets, see Prebid.js Native Implementation Guide on the Prebid site.
Multi-format ad units
Index supports multi-format ad units, see Show Multi-Format Ads with Prebid.js. For multi-format ad units, you can optionally specify a different siteId for each multi-format type at the bidder level. This is useful if you have deals set up with Index at the siteId level. See multi-format examples here.
The following are the parameters that you can specify for each multi-format type at the bidder level.
Name | Scope | Type | Description |
---|---|---|---|
siteId |
Required | String | An Index-specific identifier that is associated with this ad unit. This is similar to a placement ID or an ad unit ID that some other modules have. For example, '9999990' , '9999991' , '9999992' . Note: This will also act as the default siteID for multi-format adunits if a format specific siteId is not provided. |
banner.siteId |
Optional | String | An Index-specific identifier that is associated with this ad unit. This siteId will be prioritized over the default siteID for banner format in the multi-format ad unit. |
video.siteId |
Optional | String | An Index-specific identifier that is associated with this ad unit. This siteId will be prioritized over the default siteID for video format in the multi-format ad unit. |
native.siteId |
Optional | String | An Index-specific identifier that is associated with this ad unit. This siteId will be prioritized over the default siteID for native format in the multi-format ad unit. |
Examples
Banner
var adUnits = [{
code: 'banner-div-a',
mediaTypes: {
banner: {
sizes: [
[300, 250],
[300, 600]
]
}
},
bids: [{
bidder: 'ix',
params: {
siteId: '9999990'
}
}
]
}];
Video (instream):
Note: context
can either be 'instream'
or 'outstream'
.
var adUnits = [{
code: 'video-div-a',
mediaTypes: {
video: {
// Preferred location as of version 4.43
context: 'instream',
playerSize: [300, 250],
api: [2],
protocols: [2, 3, 5, 6],
minduration: 5,
maxduration: 30,
mimes: ['video/mp4', 'application/javascript'],
placement: 3,
plcmt: 1
}
},
bids: [{
bidder: 'ix',
params: {
siteId: '9999990',
video: {
// openrtb v2.5 compatible video obj
// If required, use this to override mediaTypes.video.XX properties
}
}
}]
}];
Video (outstream)
var adUnits = [{
code: 'div-gpt-ad-1571167646410-1',
mediaTypes: {
video: {
playerSize: [640, 360],
context: 'outstream',
api: [2],
protocols: [2, 3, 5, 6],
minduration: 5,
maxduration: 30,
mimes: ['video/mp4', 'application/javascript'],
placement: 3,
plcmt: 4,
playbackmethod: 6
}
},
bids: [{
bidder: 'ix',
params: {
siteId: '9999990'
video: {
playerConfig: {
floatOnScroll: true,
floatSize: [300,250]
}
}
}
}]
}];
Prebid Native
pbjs.addAdUnits({
code: slot.code,
mediaTypes: {
native: {
ortb: {
assets: [{
id: 1,
required: 1,
img: {
type: 3,
w: 150,
h: 50,
}
},
{
id: 2,
required: 1,
title: {
len: 80
}
},
{
id: 3,
required: 1,
data: {
type: 1
}
},
{
id: 4,
required: 1,
data: {
type: 2
}
},
{
id: 6,
required: 1,
img: {
type: 1,
w: 50,
h: 50,
}
}]
}
}
},
bids: [{
bidder: 'ix',
params: {
siteId: '9999990'
}
}]
});
Multi-format SiteId Overrides
var adUnits = [{
code: slot.code,
mediaTypes: {
banner: {
sizes: [300,250]
},
native: {
title: {
required: false
},
image: {
required: true
},
sponsoredBy: {
required: false
},
body: {
required: false
}
},
video: {
playerSize: sizes,
context: 'outstream',
api:[2],
protocols: [2, 3, 5, 6],
minduration: 5,
maxduration: 30,
mimes: ['video/mp4','application/javascript']
}
},
bids: [
{
bidder: 'ix',
params: {
siteId: '9999990',
video: {
siteId: '9999991'
},
native: {
siteId: '9999992'
},
banner: {
siteId: '9999993'
}
}
},
]
}];
"Send All Bids" Ad Server Keys
These are the bidder-specific keys that would be targeted within GAM in a Send-All-Bids scenario. GAM truncates keys to 20 characters.hb_pb_ix |
hb_bidder_ix |
hb_adid_ix |
hb_size_ix |
hb_source_ix |
hb_format_ix |
hb_cache_host_ix |
hb_cache_id_ix |
hb_uuid_ix |
hb_cache_path_ix |
hb_deal_ix |