Real-Time Bidding Protocol Buffer v.342

// Open beta protocol version: v.342
import "google/protobuf/struct.proto";

// This is the message that Google uses to request bids. A BidRequest
// includes the ad slot from a single impression.
message BidRequest {
// Unique request id generated by Google. This is 16 bytes long.
required bytes id = 2;

// -----------------------------------------------------------
// This section lists information that we know about the user.
//
// The first 3 bytes of the IP address in network byte order for IPv4, or the
// first 6 bytes for IPv6. Note that the number and position of the bytes
// included from IPv6 addresses may change later.
optional bytes ip = 4;

// Reasons for special treatment of user data (google_user_id,
// hosted_match_data, IDFA, etc).
enum UserDataTreatment {
// The current request should be treated as child-directed for purposes of
// the Children's Online Privacy Protection Act. See
// https://support.google.com/admanager/answer/4442399 for more information.
TAG_FOR_CHILD_DIRECTED_TREATMENT = 0;
}

// Deprecated. This will be removed in March 2024.
// When user_data_treatment is set, the user's cookie/id data is cleared from
// the request and is not sent in callout.
// The impacted fields are:
// * google_user_id
// * hosted_match_data
// * mobile.encrypted_advertising_id
// * mobile.encrypted_hashed_idfa
// * session_id
repeated UserDataTreatment user_data_treatment = 49 [deprecated = true];

// The Google ID for the user. This field is the unpadded web-safe base64
// encoded version of a binary cookie id. See the "Base 64 Encoding with URL
// and Filename Safe Alphabet" section in RFC 3548 for encoding details. This
// field may be the same as the Google ID returned by the cookie matching
// service. Not set if there is one or more user_data_treatment value.
optional string google_user_id = 21;

// The version number of the google_user_id. We may sometimes change the
// mapping from cookie to google_user_id. In this case the version will be
// incremented.
optional uint32 cookie_version = 20;

// The time in seconds since the google_user_id was created.
// This number may be quantized.
optional int32 cookie_age_seconds = 31;

// Match data stored for this google_user_id through the cookie matching
// service. If a match exists, then this field holds the decoded data that
// was passed in the google_hm parameter.
// Not set if there is one or more user_data_treatment value.
optional bytes hosted_match_data = 37;

// Represents a short-lived user session on CTV/OTT devices,
// with a maximum session duration of 6 hours.
// The use of session_id is never allowed for ads personalization.
// session_id may only be used for frequency capping, competitive exclusions
// or related purposes.
optional string session_id = 65;

// Time in seconds since the first ad request in a given app or site session.
// The session is reset after a sufficiently long break in user activity.
// Currently, the field is only supported for mobile app requests.
optional int32 session_duration_seconds = 83;

// A pseudonymized identifier created and controlled by the publisher for use
// in frequency capping, audience segmentation and targeting, and sequential
// ad rotation. See https://support.google.com/admanager/answer/2880055.
optional string publisher_provided_id = 79;

// Publisher first-party identifier scoped to a single site, app or vendor.
message PublisherFirstPartyId {
// Specifies how an ID is scoped and the type of requests it is used with.
enum IdType {
// A default value that should not be used.
UNKNOWN = 0;

// A site-scoped cookie for requests from web browsers.
SITE_SCOPED_COOKIE = 1;
}

// The type of the ID. This specifies how it is scoped and the type of
// requests it is used with.
optional IdType id_type = 1;

// The value of the ID.
optional string id = 2;
}
optional PublisherFirstPartyId publisher_first_party_id = 85;

// A string that identifies the browser and type of device that sent the
// request. Certain data may be redacted or replaced.
optional string user_agent = 6;

// Information about privacy treatments that apply to an ad opportunity
// offered through this request.
message PrivacyTreatments {
// Generalization that can be applied to the BidRequest.ip field.
enum IpGeneralization {
// The BidRequest.ip field is truncated, /24 for IPv4 and /48 for IPv6.
// IPv4 addresses are truncated to 3-byte strings, representing the
// first three octets of an IP address. IPv6 addresses are truncated to
// 6-byte strings, representing the first 6 octets of an IP address.
IP_TRUNCATED = 0;

// The BidRequest.ip field is redacted.
IP_REDACTED = 2;
}

// Generalization for the BidRequest.ip field.
optional IpGeneralization ip = 1;

// Generalization that can be applied to the user_agent and user_agent_data
// fields.
enum UserAgentGeneralization {
// The user_agent and user_agent_data fields are both provided in full.
USER_AGENT_FULL = 0;

// The user_agent and user_agent_data fields are generalized, which can
// include limiting browser and OS version information to major versions
// only and other changes to protect user privacy.
USER_AGENT_COARSE = 1;
}

// Generalization that was applied to the user_agent and user_agent_data
// fields, if any.
optional UserAgentGeneralization user_agent = 2;

// Specifies the reasons that ads returned in response to this request
// should not be personalized. This signal does not reflect user decisions
// on surfaces including iOS App Tracking Transparency
// (https://developer.apple.com/documentation/apptrackingtransparency) or
// Android advertising ID
// (https://support.google.com/googleplay/android-developer/answer/6048248).
// See BidRequest.device.limit_ad_tracking and
// BidRequest.device.app_tracking_authorization_status fields for more
// information.
enum NonPersonalizedAdsReason {
UNKNOWN = 0;

// The publisher has declared that this request should serve
// non-personalized ads independent of other signals.
// https://support.google.com/admanager/answer/9005435#npa
PUBLISHER_DECLARED_NPA = 1;

// The publisher has requested restricted data processing for this
// request. https://support.google.com/authorizedbuyers/answer/11121285
RESTRICT_DATA_PROCESSING = 2;

// The user has opted out of ads personalization.
USER_OPT_OUT = 3;
}
repeated NonPersonalizedAdsReason non_personalized_ads_reason = 6 [packed =
true];

// True if publisher grants the permission to allow the bidder to use bid
// request data to build user profiles for uses such as interest-based ads
// and remarketing. To use this data to build user profiles, a bidder must
// also win a given impression.
// Learn more about data collection controls:
// https://support.google.com/admanager/answer/11956152
optional bool allow_user_data_collection = 7;

// Reasons why on-device storage access could be restricted during the
// delivery of a winning ad.
enum DeviceStorageRestrictionReason {
DEVICE_STORAGE_RESTRICTION_UNKNOWN = 0;

// This request is subject to user consent requirements to allow for
// device storage access for advertising use cases such as ads
// measurement, frequency capping, or profiling, but consent was
// insufficient or not provided.
INSUFFICIENT_USER_CONSENT = 1;
}

// Indicates the reason why access of local device storage during winning ad
// rendering and measurement is restricted.
optional DeviceStorageRestrictionReason device_storage_restriction_reason =
8;
}
optional PrivacyTreatments privacy_treatments = 71;

// Data segments that describe the content or audience.
message SegmentData {
// The Google assigned ID of the data provider. For the list of data
// providers, see
// https://storage.googleapis.com/adx-rtb-dictionaries/data_providers.txt.
optional string id = 5;

// Exchange-specific name for the signal provider.
optional string name = 1;

// Segment objects contain segment IDs that can be used with the taxonomy
// type to access first party data.
message Segment {
// ID of the data segment specific to the signal provider.
optional string id = 1;
}
repeated Segment segment = 2;

// Identifies the taxonomy that the segment IDs belong to.
enum TaxonomyType {
TAXONOMY_TYPE_UNKNOWN = 0;

// https://github.com/InteractiveAdvertisingBureau/Taxonomies/blob/main/Audience%20Taxonomies/Audience%20Taxonomy%201.1.tsv
IAB_AUDIENCE_1_1 = 4;

// https://github.com/InteractiveAdvertisingBureau/Taxonomies/blob/main/Content%20Taxonomies/Content%20Taxonomy%202.2.tsv
IAB_CONTENT_2_2 = 6;

// https://github.com/InteractiveAdvertisingBureau/Taxonomies/blob/main/Content%20Taxonomies/Content%20Taxonomy%203.0.tsv
IAB_CONTENT_3_0 = 7;
}

// The taxonomy in use for segment IDs.
optional TaxonomyType type = 3;
}

// Data segments for Publisher Provided Signals:
// https://support.google.com/admanager/answer/12451124
repeated SegmentData segment_data = 75;

// Experimental field; subject to change.
// A coarse-grained topic that a website visitor might currently be interested
// in based on recent browsing activity. See
// https://developer.chrome.com/docs/privacy-sandbox/topics/ and/or
// https://privacysandbox.com/intl/en_us/proposals/topics/ for more
// information about the Topics API. Reach out to your account manager to
// participate in the Topics API experiment.
message Topic {
// The value of a topic ID. A numerical identifier corresponding to a
// coarse-grained advertising topic. See
// https://github.com/patcg-individual-drafts/topics/blob/main/taxonomy_v1.md
// for a list of topics in the initial taxonomy.
optional int32 id = 1;

// The version of the advertising taxonomy which defines the semantic
// meaning of each topic ID for the topics, for example "v1".
optional string taxonomy_version = 2;

// The version of the classifier used by the browser to map hostnames to
// topic IDs in the taxonomy.
optional string classifier_version = 3;
}

// The list of topics that a website visitor might currently be interested in
// inferred by the browser based on recent browsing activity. See
// https://developer.chrome.com/docs/privacy-sandbox/topics/ and/or
// https://privacysandbox.com/intl/en_us/proposals/topics/ for more
// information about Topics API.
repeated Topic topics = 74;

// Structured user agent information, which can be used when a client
// supports User-Agent Client Hints: https://wicg.github.io/ua-client-hints/
//
// Note: When available, fields are sourced from Client Hints HTTP headers
// or equivalent JavaScript accessors from the NavigatorUAData interface.
// For agents that have no support for User-Agent Client Hints, an exchange
// can also extract information from the parsed User-Agent header, so this
// object can always be used as the source of the user agent information.
message UserAgent {
// Identifies a device's browser or similar software component, and the
// user agent's execution platform or operating system.
message BrandVersion {
// A brand identifier, for example, "Chrome" or "Windows". The value may
// be sourced from the User-Agent Client Hints headers, representing
// either the user agent brand (from the Sec-CH-UA-Full-Version header)
// or the platform brand (from the Sec-CH-UA-Platform header).
optional string brand = 1;

// A sequence of version components, in descending hierarchical order
// (major, minor, micro, ...).
repeated string version = 2;
}

// Each BrandVersion object identifies a browser or similar software
// component. Exchanges should send brands and versions derived from
// the Sec-CH-UA-Full-Version-List header.
repeated BrandVersion browsers = 8;

// Identifies the user agent's execution platform / OS. Exchanges should
// send a brand derived from the Sec-CH-UA-Platform header, and version
// derived from the Sec-CH-UAPlatform-Version header.
optional BrandVersion platform = 2;

// True if the agent prefers a "mobile" version of the content if
// available, meaning optimized for small screens or touch input. False
// if the agent prefers the "desktop" or "full" content. Exchanges should
// derive this value from the Sec-CH-UAMobile header.
optional bool mobile = 3;

// Device's major binary architecture, for example, "x86" or "arm".
// Exchanges should retrieve this value from the Sec-CH-UA-Arch header.
optional string architecture = 4;

// Device's bitness, for example, "64" for 64-bit architecture. Exchanges
// should retrieve this value from the Sec-CH-UA-Bitness header.
optional string bitness = 9;

// Device model. Exchanges should retrieve this value from the
// Sec-CH-UAModel header.
optional string model = 5;

// Possible sources for User-Agent data. In the case of Client Hints headers
// the source also distinguishes between requests that are restricted to
// the low-entropy headers and requests that don't have that restriction;
// see wicg.github.io/client-hints-infrastructure/#low-entropy-hint-table.
enum Source {
UNKNOWN_SOURCE = 0;

// User-Agent Client Hints (only low-entropy headers were available).
CLIENT_HINTS_LOW_ENTROPY = 1;

// User-Agent Client Hints (with high-entropy headers available).
CLIENT_HINTS_HIGH_ENTROPY = 2;

// Parsed from User-Agent header.
USER_AGENT_STRING = 3;
}

// The source of data for the User Agent information.
optional Source source = 10;
}

// Structured user agent information. If both BidRequest.ua and
// BidRequest.sua are present, BidRequest.sua should be considered the
// more accurate representation of the device attributes. This is because
// BidRequest.ua may contain a frozen or reduced user agent string.
optional UserAgent user_agent_data = 63;

// The billing address country of the publisher. This may be different from
// the detected country of the user in geo_criteria_id or the hosting country
// of the website. For a complete list of country codes, refer to
// https://developers.google.com/google-ads/api/data/codes-formats#country_codes
optional string publisher_country = 55;

// The ID of the host publisher. When populated, indicates that the host
// publisher participated in revenue sharing, and the ID can be used to
// authorize ads.txt.
optional string host_publisher_id = 73;

// The domain of the partner (of the site/app owner) with ownership
// of some portion of ad inventory on the site/app. The partner's ads.txt or
// app-ads.txt file will be hosted here. More detail at
// http://iabtechlab.com/wp-content/uploads/2021/03/ctv-app-ads-explainer-guide.pdf
optional string inventory_partner_domain = 72;

// Location of the end user. Uses a subset of the codes used in the Google
// Ads API. See the geo-table.csv table in the technical documentation for a
// list of IDs. The geo_criteria_id field replaces the deprecated country,
// region, city, and metro fields.
// It is recommended that BidRequest.geo be used instead of this field.
// See Geotargeting Guide:
// https://developers.google.com/authorized-buyers/rtb/geotargeting
optional int32 geo_criteria_id = 39;

// The user's approximate geographic location. All location information is
// IP geolocation-derived. The lat/lon fields may be a reference position
// (for example, centroid) for the IP geolocation-derived location that's also
// carried by the other fields (for example, a city), and accuracy will be the
// radius of a circle with the approximate area of that location. Location and
// its accuracy will be fuzzified as necessary to protect user privacy. See
// Geotargeting Guide:
// https://developers.google.com/authorized-buyers/rtb/geotargeting
message Geo {
// Latitude from -90.0 to +90.0, where negative is south.
optional double lat = 1;

// Longitude from -180.0 to +180.0, where negative is west.
optional double lon = 2;

// Country using ISO-3166-1 Alpha-3.
optional string country = 3;

// Region code using ISO-3166-2; 2-letter state code if USA.
optional string region = 4;

// Google metro code; similar to but not exactly Nielsen DMAs.
optional string metro = 6;

// City using United Nations Code for Trade & Transport Locations.
// (https://www.unece.org/cefact/locode/service/location.htm).
optional string city = 7;

// Zip/postal code.
optional string zip = 8;

// Estimated location accuracy in meters.
optional int32 accuracy = 11;

// Local time as the number +/- of minutes from UTC.
optional int32 utcoffset = 10;
}
optional Geo geo = 62;

// Deprecated. This field will be removed in Q3 2023. It is recommended that
// BidRequest.geo.zip be used instead. See Geotargeting Guide:
// https://developers.google.com/authorized-buyers/rtb/geotargeting
// Detected postal code of the appropriate type for the country of the end
// user (for example, zip code if the country is "US"). The postal_code_prefix
// field is set when accuracy is too low to imply a full code, otherwise the
// postal_code field is set.
optional string postal_code = 33 [deprecated = true];

// Deprecated. This field will be removed in Q3 2023. It is recommended that
// BidRequest.geo is used instead. See Geotargeting Guide:
// https://developers.google.com/authorized-buyers/rtb/geotargeting
// Encrypted hyperlocal targeting signals.
optional bytes encrypted_hyperlocal_set = 40 [deprecated = true];

// Coarse geolocation information approximated based on the IP address of the
// device the ad request originated from.
message Hyperlocal {
// A location on the Earth's surface.
message Point {
optional float latitude = 1;
optional float longitude = 2;
}

// The device can be at any point inside the geofence polygon defined by a
// list of corners. Currently, the polygon is always a parallelogram with 4
// corners.
repeated Point corners = 1;
}

message HyperlocalSet {
// This field currently contains at most one hyperlocal polygon.
repeated Hyperlocal hyperlocal = 1;

// The approximate geometric center of a geofence area. It is calculated
// exclusively based on the geometric shape of the geofence area and in no
// way indicates the mobile device's actual location within the geofence
// area. If multiple hyperlocal polygons are specified above then
// center_point is the geometric center of all hyperlocal polygons.
optional Hyperlocal.Point center_point = 2;
}

// Deprecated. This field will be removed in Q3 2023. It is recommended that
// BidRequest.geo is used instead. See Geotargeting Guide:
// https://developers.google.com/authorized-buyers/rtb/geotargeting
// Unencrypted version of encrypted_hyperlocal_set. This field is only set
// when using an SSL connection.
optional HyperlocalSet hyperlocal_set = 53 [deprecated = true];

// Deprecated. This field will be removed in Q3 2023. It is recommended that
// BidRequest.geo is used instead. See Geotargeting Guide:
// https://developers.google.com/authorized-buyers/rtb/geotargeting
// The offset of the user's time from GMT in minutes. For example, GMT+10 is
// timezone_offset = 600.
optional int32 timezone_offset = 25 [deprecated = true];

// This field is not populated by default. We recommend that bidders instead
// store and look up list ids using either google_user_id or hosted_match_data
// as keys.
message UserList {
// The user list id.
optional int64 id = 1;

// The time in seconds since the user was added to the list.
optional int32 age_seconds = 2;
}
repeated UserList user_list = 32;

// -----------------------------------------------------------
// This section lists information that we know about the web page or mobile
// application where the impression originates.
//
// The publisher ID as defined by the publisher code suffix of
// the web property code. For instance, "pub-123" is the publisher code of web
// property code "ca-pub-123" (ca- is the product specific prefix of the web
// property).
optional string publisher_id = 56;

// Deprecated. This field will be removed in Q2 2024.
// The seller network id. See seller-network-ids.txt file in the technical
// documentation for a list of ids. This is only set if the site is not
// anonymous and the publisher allows site targeting.
optional int32 seller_network_id = 41 [deprecated = true];

// Id for the partner that provides this inventory. This is only set when
// seller_network_id is also set and further partner information beyond the
// seller_network_id is also available. The value of the partner_id is not
// meaningful beyond providing a stable identifier.
optional fixed64 partner_id = 52;

// The URL of the page with parameters removed. This is only set if the
// publisher allows site targeting. This always starts with a protocol (either
// http or https).
optional string url = 11;

// Indicates that the request is using semi-transparent branding,
// which means only a truncated version of the request URL will
// be provided. This decision is made by the publisher, see
// https://support.google.com/admanager/answer/4584891#urls for context.
optional bool is_semi_transparent_request = 67;

// Detected user languages, based on the language of the web page, the browser
// settings, and other signals. The order is arbitrary. The codes are 2 or 5
// characters and are documented at
// https://developers.google.com/google-ads/api/data/codes-formats#languages
repeated string detected_language = 12;

// One or more detected verticals for the page as determined by Google.
message Vertical {
// The vertical id. See the publisher-verticals.txt file in the technical
// documentation for a list of ids.
required int32 id = 1;

// Weight for this vertical, in the (0.0, 1.0] range. More relevant
// verticals have higher weights.
required float weight = 2;
}

// Unordered list of detected content verticals. See the
// publisher-verticals.txt file in the technical documentation for a list of
// ids.
repeated Vertical detected_vertical = 13;

// List of detected content labels. See content-labels.txt file in the
// technical documentation for a list of ids.
repeated int32 detected_content_label = 26 [packed = true];

// The production quality of the content. See
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list--production-qualities-
// for details.
enum ProductionQuality {
QUALITY_UNKNOWN = 0;

// Content that is usually created or produced by media and entertainment
// companies using professional-grade equipment, talent, and production
// crews that hold or maintain the rights for distribution and syndication.
PROFESSIONAL = 1;

// Consumer or user-generated content that has professional or industrial
// qualities (e.g. shot with professional-grade equipment, using
// professional talent, etc.).
PROSUMER = 2;

// Publicly available video content that is created or produced by
// end users.
USER_GENERATED = 3;
}

// The production quality of the content where an ad can be shown, as
// determined by the publisher.
optional ProductionQuality production_quality = 80 [default =
QUALITY_UNKNOWN];

// The rating of the content. See
// https://support.google.com/admanager/answer/12451124#content-rating for
// details.
enum ContentRating {
RATING_UNKNOWN = 0;

// Content suitable for general audiences.
GENERAL_AUDIENCES = 1;

// Content suitable for most audiences with parental guidance.
PARENTAL_GUIDANCE = 2;

// Content suitable for teen and older audiences.
TEEN = 3;

// Content suitable only for mature audiences.
MATURE_AUDIENCES = 4;
}

// The rating of the content where an ad can be shown.
optional ContentRating content_rating = 84 [default = RATING_UNKNOWN];

// This represents a unique ID for the overall query. In the event
// that there are multiple callouts for a query, all callout requests for that
// query will contain the same google_query_id.
optional string google_query_id = 59;

// The type of auction that will be run for this query.
enum AuctionType {
UNKNOWN_AUCTION_TYPE = 0;
FIRST_PRICE = 1;
SECOND_PRICE = 2;
FIXED_PRICE = 3;
}
optional AuctionType auction_type = 60 [default = SECOND_PRICE];

// Information about the device.
message Device {
// The type of device on which the ad will be shown.
enum DeviceType {
UNKNOWN_DEVICE = 0;
HIGHEND_PHONE = 1;
TABLET = 2;

// Desktop or laptop devices.
PERSONAL_COMPUTER = 3;

// Both connected TVs (that is, smart TVs) and connected devices
// (such as Roku and Apple TV).
CONNECTED_TV = 4;
GAME_CONSOLE = 5;
SET_TOP_BOX = 6;
}
optional DeviceType device_type = 1 [default = UNKNOWN_DEVICE];

// The platform of the device. Examples: android, iphone, palm
optional string platform = 2 [default = ""];

// The brand of the device (for example, "Apple" or "Samsung").
optional string brand = 3 [default = ""];

// Device model (for example, "pixel 7 pro"). For iPhone/iPad, this
// field contains Apple's model identifier string (such as "iPhone12,1" and
// "iPad13,8") if available. Otherwise this field contains the generic
// model (either "iphone" or "ipad").
optional string model = 4 [default = ""];

// Contains the OS version of the platform. For instance, for Android 2,
// major=2, minor=0. For iPhone 3.3.1, major=3 and minor=3.
message OsVersion {
optional int32 major = 1 [default = -1];
optional int32 minor = 2 [default = -1];
optional int32 micro = 3 [default = -1];
}

// The OS version; for example, 2 for Android 2.1, or 3.3 for iOS 3.3.1.
optional OsVersion os_version = 5;

// Unique identifier for the mobile carrier if the device is connected to
// the internet through a carrier (as opposed to through WiFi). To look up
// carrier name from carrier ID, refer to:
// https://storage.googleapis.com/adx-rtb-dictionaries/mobile-carriers.csv.
optional int64 carrier_id = 6 [default = 0];

// The width of the device screen in pixels.
optional int32 screen_width = 7 [default = 0];

// The height of the device screen in pixels.
optional int32 screen_height = 8 [default = 0];

// Used for high-density devices (for example, iOS retina displays). A
// non-default value indicates that the nominal screen size (with pixels as
// the unit) does not describe the actual number of pixels in the screen.
// For example, nominal width and height may be 320x640 for a screen that
// actually has 640x1280 pixels, in which case screen_width=320,
// screen_height=640, and screen_pixel_ratio_millis=2000, since each axis
// has twice as many pixels as its dimensions would indicate.
optional int32 screen_pixel_ratio_millis = 9 [default = 0];
enum ScreenOrientation {
UNKNOWN_ORIENTATION = 0;
PORTRAIT = 1;
LANDSCAPE = 2;
}

// The screen orientation of the device when the ad request is sent.
optional ScreenOrientation screen_orientation = 10 [default =
UNKNOWN_ORIENTATION];

// Hardware version of the device. For iPhone/iPad, this field contains
// Apple's model identifier string (such as "iPhone12,1" and "iPad13,8") if
// available.
optional string hardware_version = 11;

// "Limit Ad Tracking" is a commercially endorsed signal based on the
// operating system or device settings, where `false` indicates that
// tracking is unrestricted and `true` indicates that tracking must be
// limited per commercial guidelines.
//
// This signal reflects user decisions on surfaces including iOS App
// Tracking Transparency:
// https://developer.apple.com/documentation/apptrackingtransparency
// See also lmt and App Tracking Transparency guidance:
// https://github.com/InteractiveAdvertisingBureau/openrtb/blob/master/extensions/community_extensions/skadnetwork.md#dnt-lmt-and-app-tracking-transparency-guidance
// and Android advertising ID:
// https://support.google.com/googleplay/android-developer/answer/6048248
optional bool limit_ad_tracking = 12;

// The possible app tracking authorization statuses that could be applicable
// for bid requests from iOS devices. For more information about iOS's app
// tracking authorization status, see:
// https://developer.apple.com/documentation/apptrackingtransparency/attrackingmanager/authorizationstatus
enum AuthorizationStatus {
// User has not yet received a request to authorize access to app-related
// data that can be used for tracking the user or the device.
NOT_DETERMINED = 0;

// Authorization to access app-related data that can be used for tracking
// the user or the device is restricted.
RESTRICTED = 1;

// User denies authorization to access app-related data that can be used
// for tracking the user or the device.
DENIED = 2;

// User authorizes access to app-related data that can be used for
// tracking the user or the device.
AUTHORIZED = 3;
}

// This field is only populated for iOS devices. Indicates the app tracking
// authorization status. This value is retrieved from ATTrackingManager
// and provided as is. For more information about iOS's app tracking
// authorization status, see:
// https://developer.apple.com/documentation/apptrackingtransparency/attrackingmanager/authorizationstatus
optional AuthorizationStatus app_tracking_authorization_status = 13;

// Possible types of the device's network connection.
enum ConnectionType {
CONNECTION_UNKNOWN = 0;

// Ethernet; Wired Connection
ETHERNET = 1;

// WiFi
WIFI = 2;

// Mobile Network - Unknown Generation
CELL_UNKNOWN = 3;

// Mobile Network - 2G
CELL_2G = 4;

// Mobile Network - 3G
CELL_3G = 5;

// Mobile Network - 4G
CELL_4G = 6;

// Mobile Network - 5G
CELL_5G = 7;
}

// The type of network to which the user's device is connected.
//
// For 5G connection type, we send CELL_4G instead of CELL_5G.
optional ConnectionType connection_type = 15 [default = CONNECTION_UNKNOWN];

// Chrome-facilitated cookie deprecation testing label as received from
// Chrome.
// https://developer.chrome.com/en/docs/privacy-sandbox/chrome-testing/
optional string cookie_deprecation_label = 17;
}
optional Device device = 54;

// Additional key-value attributes. Currently unused.
message KeyValue {
optional string key = 1;
optional string value = 2;
}
repeated KeyValue key_value = 38;

// Information for ad queries coming from mobile devices. A mobile device is
// either a mobile phone or a tablet. This is present for ad queries both from
// mobile devices browsing the web and from mobile apps.
message Mobile {
// If true, then this request is from a mobile application. For branded
// requests, app_id will also be filled in. If the request is from a mobile
// web page contained inside an app, is_app will still be false, but app_id
// could be filled in with the app identifier. For SDK-less requests (mostly
// from connected TVs), this will be true if an app ID is provided directly
// in the request.
optional bool is_app = 7 [default = false];

// The identifier of the mobile app when this ad query comes from a mobile
// app, or from a mobile web page contained inside an app. If the app was
// downloaded from the Apple iTunes app store, then this is the app-store
// id, for example, 343200656. For Android devices, this is the fully
// qualified package name, for example, com.rovio.angrybirds. For Windows
// devices it's the App ID, for example,
// f15abcde-f6gh-47i0-j3k8-37l93817mn3o. For SDK-less requests (mostly from
// connected TVs), the app ID provided by the publisher directly in the
// request.
optional string app_id = 6;

// If true, then this is a mobile full screen ad request.
optional bool is_interstitial_request = 10 [default = false];

// This field contains the IDs of categories to which the current mobile app
// belongs. This field will be empty if is_app is false. The mapping between
// mobile apps and categories is defined by the Google Play Store for
// Android apps, or the Apple iTunes Store for iOS apps. To look up category
// name from category ID, refer to
// https://developers.google.com/google-ads/api/data/codes-formats#mobile_app_categories
repeated int32 app_category_ids = 11;

// For a mobile web request, this field indicates whether the page is
// optimized for mobile browsers on high-end mobile phones.
optional bool is_mobile_web_optimized = 17 [default = false];

// Indicates whether a mobile app bid request is for an app open ad.
// See App open ad guidance at
// https://support.google.com/admob/answer/9341964 for more information.
optional bool is_app_open_ad = 36 [default = false];

// This field is used for advertising identifiers for
// 1) iOS devices (This is called Identifier for Advertising, or IDFA, as
// described at https://support.google.com/authorizedbuyers/answer/3221407),
// 2) Android devices,
// 3) Roku devices,
// 4) Microsoft Xbox devices,
// 5) Amazon devices (for example, Amazon Fire).
//
// When the encrypted_advertising_id is an IDFA, the plaintext after
// decrypting the ciphertext is the IDFA (16 byte UUID) returned by iOS's
// [ASIdentifierManager advertisingIdentifier]. For encrypted_hashed_idfa,
// the plaintext is the 16 byte MD5 hash of the IDFA. Only one of the two
// fields will be available, depending on the version of the SDK making the
// request. Later SDKs provide unhashed values. They are not set if there is
// one or more user_data_treatment value in the BidRequest.
optional bytes encrypted_advertising_id = 20;

// Unencrypted version of encrypted_advertising_id. This field is only set
// when using an SSL connection. This field is a 16 byte UUID (binary form)
// or a 32 byte alphanumeric id (such as Samsung ID).
optional bytes advertising_id = 27;
optional bytes encrypted_hashed_idfa = 21;

// Unencrypted version of encrypted_hashed_idfa. This field is only set
// when using an SSL connection. This field is a 16 byte MD5.
optional bytes hashed_idfa = 28;

// App names for Android apps are from the Google Play store.
// App names for iOS apps are provided by App Annie
// (https://www.appannie.com). App names for SDK-less requests (mostly from
// connected TVs) are provided by the publisher directly in the request.
optional string app_name = 24;

// Average user rating for the app. The range of user rating is between 1.0
// and 5.0. Currently only available for apps in Google Play store.
optional float app_rating = 25;

// Identification of and information about an SDK installed in the
// publisher's app that the bidder has access to, often because it's the
// bidder's SDK.
message InstalledSdk {
// Identifier for the installed SDK.
optional string id = 1;

// Semantic version of the installed SDK and the adapter that communicates
// between the installed SDK and Google's SDK.
message Version {
optional int32 major = 1 [default = -1];
optional int32 minor = 2 [default = -1];
optional int32 micro = 3 [default = -1];
}

// The version of the installed SDK.
optional Version sdk_version = 2;

// The version of the adapter that communicates with the installed SDK.
optional Version adapter_version = 3;
}
repeated InstalledSdk installed_sdk = 32;

// Publisher's SKAdNetwork information to support app installation
// attribution for iOS 14 and later. Apple's SKAdNetwork API helps
// advertisers measure ad-driven app installation by sending a postback
// to the ad network after a successful install. Publishers will need
// to configure supported ad networks in their app's property list
// (Info.plist) to allow an install to be attributed to the ad impression.
// For more info visit:
// https://developer.apple.com/documentation/storekit/skadnetwork
message SKAdNetworkRequest {
// List of all SKAdNetwork versions supported by the request, depending on
// the OS version and the SDK version.
repeated string versions = 4;

// ID of publisher app in Apple's App Store.
optional string sourceapp = 2;

// SKAdNetworkIdentifier entries in the publisher app's Info.plist.
repeated string skadnetids = 3;

// List of fidelity types supported, depending on the SKAdNetwork API
// version supported by the operating system and SDK as well as ad slot
// properties.
repeated SKAdNetworkFidelityType supported_fidelity_types = 5 [packed =
true];

// Indicates if this request supports SKOverlay for video ads.
optional bool skoverlay = 6;
}
optional SKAdNetworkRequest skadn = 34;
}
optional Mobile mobile = 28;

// Information about the video if this is an in-video ad request.
message Video {
// Describes where the video ad will play.
enum Placement {
UNKNOWN_PLACEMENT = 0;

// Instream means the ad plays before, during, or after other video
// content. This is similar to a traditional TV commercial. The video
// content the user is watching does not play while the ad is playing.
INSTREAM = 1;

// Interstitial means the video ad plays in front of non-video content,
// (for example, a news article or video game). The ad covers all or
// nearly all of the space on the screen occupied by the content and the
// user is not able to proceed to the content until the ad has finished or
// been skipped.
INTERSTITIAL = 2;

// The in-feed video format is a video creative that shows within a feed
// of content, typically a social app feed, a list of editorial content
// items, etc, as the user is scrolling. It renders centered and not to
// the side.
IN_FEED = 3;

// Audio is a request for an ad that is an audio stream. It is distinct
// from INSTREAM above as that is exclusive to video requests.
AUDIO = 4;

// The in-article video format is a video creative that loads and plays
// between paragraphs of editorial content as a standalone video player.
IN_ARTICLE = 5;
}

// Deprecated. This will be removed in January 2025 per the IAB here:
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/main/AdCOM%20v1.0%20FINAL.md#list--placement-subtypes---video-
optional Placement placement = 16 [deprecated = true, default =
UNKNOWN_PLACEMENT];

// Possible video placement types. See:
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list--plcmt-subtypes---video-
enum Plcmt {
PLCMT_UNKNOWN = 0;

// Pre-roll, mid-roll, and post-roll ads that are played before, during or
// after the streaming video content that the consumer has requested.
// Instream video must be set to “sound on” by default at player start, or
// have explicitly clear user intent to watch the video content. While
// there may be other content surrounding the player, the video content
// must be the focus of the user’s visit. It should remain the primary
// content on the page and the only video player in-view capable of audio
// when playing. If the player converts to floating/sticky, subsequent ad
// calls should accurately convey the updated player size.
PLCMT_INSTREAM = 1;

// Pre-roll, mid-roll, and post-roll ads that are played before, during,
// or after streaming video content. The video player loads and plays
// before, between, or after paragraphs of text or graphical content, and
// starts playing only when it enters the viewport. Accompanying content
// should only start playback upon entering the viewport. It may convert
// to a floating/sticky player as it scrolls off the page.
PLCMT_ACCOMPANYING_CONTENT = 2;

// Video ads that are played without video content. During playback, it
// must be the primary focus of the page and take up the majority of the
// viewport and cannot be scrolled out of view. This can be in placements
// like in-app video or slideshows.
PLCMT_INTERSTITIAL = 3;

// Video ads that are played without streaming video content. This can be
// in placements like slideshows, native feeds, in-content or
// sticky/floating.
PLCMT_NO_CONTENT_STANDALONE = 4;
}

// Video placement type declared by the publisher for this impression.
// Equivalent to the Video.plcmt field introduced in OpenRTB 2.6 to reflect
// updated industry definitions around different types of video ad
// placements. This field supersedes the Video.placement field. May be unset
// if the publisher did not declare a video placement type.
optional Plcmt plcmt = 23 [default = PLCMT_UNKNOWN];

// Video placement type inferred by Google for this impression. This field
// is always filled and can be different from BidRequest.video.plcmt (the
// publisher-declared placement type).
optional Plcmt inferred_plcmt = 24 [default = PLCMT_UNKNOWN];

// The URL of the page that the publisher gives Google to describe the video
// content, with parameters removed.
optional string description_url = 10;

// If true, the video is embedded on a page outside the publisher's domain.
// When this is set, description_url points to a description of the video
// (as it always does), and the url field in BidRequest is the page in which
// the video is embedded. For example, a request for an in-stream ad in a
// Vimeo video shared on Facebook has is_embedded_offsite set. The url field
// is for a Facebook page and the description_url points to the video on
// Vimeo.
optional bool is_embedded_offsite = 11 [default = false];

// Describes how the video ad will be played. The playback method is
// determined to be auto-play, click-to-play or mouse-over based on the best
// measurement available. This includes things like how recently the user
// interacted with a web page. For auto-play, ads can start playing with the
// sound on or off. Some ads (for example, in-feed ads) are muted until the
// user interacts with the ad. Alternatively, if an ad would normally play
// with the sound on but the device is muted then the value will be set to
// sound off. For devices where it is not possible to determine if the
// device is muted (for example, desktop), we assume that sound is on.
enum VideoPlaybackMethod {
METHOD_UNKNOWN = 0;
AUTO_PLAY_SOUND_ON = 1;
AUTO_PLAY_SOUND_OFF = 2;
CLICK_TO_PLAY = 3;
MOUSE_OVER = 4;
INITIATE_ON_ENTERING_VIEWPORT_SOUND_ON = 5;
INITIATE_ON_ENTERING_VIEWPORT_SOUND_OFF = 6;
}
optional VideoPlaybackMethod playback_method = 14 [default =
METHOD_UNKNOWN];

// Whether the inventory allows clicking on the video ad to take the user to
// an advertiser site. Some platforms, notably connected TVs, do not
// support clicking on video ads, in which case this field is set to false.
optional bool is_clickable = 15;

// The time in milliseconds from the start of the video when the ad will be
// displayed. 0 means pre-roll and -1 means post-roll. The value is valid
// only if this param is set. When not set, the display position is unknown.
optional int32 videoad_start_delay = 1;

// The maximum duration in milliseconds of the ad that you should return.
// If this is not set or has value <= 0, any duration is allowed.
optional int32 max_ad_duration = 2;

// The minimum duration in milliseconds of the ad that you should return.
// If this is not set or has value <= 0, there is no minimum duration.
optional int32 min_ad_duration = 8;

// The maximum number of ads in an Adx video pod. A non-zero value indicates
// that the current ad slot is a video pod that can show multiple video
// ads. Actual number of video ads shown can be less than or equal to this
// value but cannot exceed it.
optional int32 max_ads_in_pod = 12;

// The maximum duration of a pod in seconds.
optional int32 max_pod_duration_seconds = 20;

// Does the publisher allow/require/block skippable video ads?
enum SkippableBidRequestType {
ALLOW_SKIPPABLE = 0;
REQUIRE_SKIPPABLE = 1;
BLOCK_SKIPPABLE = 2;
}
optional SkippableBidRequestType video_ad_skippable = 4 [default =
ALLOW_SKIPPABLE];

// The maximum duration in milliseconds for the ad you should return, if
// this ad is skippable (this generally differs from the maximum duration
// allowed for non-skippable ads). If this is not set or has value <= 0, any
// duration is allowed.
optional int32 skippable_max_ad_duration = 5;

// Supported video protocols.
enum VideoProtocol {
UNKNOWN_VIDEO_PROTOCOL = 0;
VAST_1_0 = 1;
VAST_2_0 = 2;
VAST_3_0 = 3;
VAST_1_0_WRAPPER = 4;
VAST_2_0_WRAPPER = 5;
VAST_3_0_WRAPPER = 6;
VAST_4_0 = 7;
VAST_4_0_WRAPPER = 8;
DAAST_1_0 = 9;
DAAST_1_0_WRAPPER = 10;
}

// Array of supported video bid response protocols.
repeated VideoProtocol protocols = 17 [packed = true];

// The video file formats that are allowed for this request. The response
// should support at least one of them.
enum VideoFormat {
UNKNOWN_VIDEO_FORMAT = -1;

// Flash video files are accepted (FLV).
VIDEO_FLV = 0;
VIDEO_MP4 = 1;

// Valid VAST ads with at least one media file hosted on youtube.com.
YT_HOSTED = 2;

// Flash VPAID (SWF).
VPAID_FLASH = 3;

// JavaScript VPAID.
VPAID_JS = 4;
AUDIO_MP3 = 5;
AUDIO_OGG = 6;

// Requires both MP3 & OGG as Google does not know
// which codecs are installed on the player.
AUDIO_MP3_OGG = 7;
VIDEO_WEBM = 8;
VIDEO_MOV = 9;
VIDEO_3GPP = 10;
VIDEO_HLS = 11;
VIDEO_DASH = 12;

// Audio version of MP4.
AUDIO_MP4A = 13;
}
repeated VideoFormat allowed_video_formats = 6;

// Information about the companion ad slots that can be shown with the
// video. While this is a repeated field there will only be one value in
// most cases. If there are no companion ads available this field will not
// be set.
message CompanionSlot {
// These fields represent the available heights and widths in this slot.
// There will always be the same number heights and widths fields.
repeated int32 height = 1 [packed = true];
repeated int32 width = 2 [packed = true];

// These are the formats of the creatives allowed in this companion ad
// slot.
enum CreativeFormat {
UNKNOWN_CREATIVE_FORMAT = -1;
IMAGE_CREATIVE = 0;
FLASH_CREATIVE = 1;
HTML_CREATIVE = 2;
}
repeated CreativeFormat creative_format = 3;
}
repeated CompanionSlot companion_slot = 7;

// End cap support. When enabled, the companion ad can be picked to be
// rendered as an end cap (info card) in the video slot after the video
// ad finishes playing. If multiple companion ads are returned, IMA SDK
// chooses one which best matches the device screen size. End cap is
// supported only on mobile video interstitial inventory.
enum EndCapSupport {
// Companion ad won't be rendered as end cap.
END_CAP_NOT_ENABLED = 0;

// End cap will be rendered if response contains
// eligible companion banner, but companion
// banner is not required.
END_CAP_OPTIONAL = 1;

// Not used at this time.
// Response with companion ad is filtered.
END_CAP_FORBIDDEN = 2;

// Not used at this time.
// Response without companion ad is filtered.
END_CAP_REQUIRED = 3;
}
optional EndCapSupport end_cap_support = 13 [default = END_CAP_NOT_ENABLED];

// Attributes of the video that the user is viewing, not the video ad.
// These fields are based on the availability of the video metadata from the
// video publisher and may not always be populated.
message ContentAttributes {
// The duration of the video, in seconds.
optional int32 duration_seconds = 2;
}
optional ContentAttributes content_attributes = 9;

// Identify whether or not the ad request is being served from a live video
// stream (0 = is not live, 1 = is live).
optional bool is_livestream = 18 [default = false];

// The event that causes playback to end. This will only be filled
// for non-instream video formats.
enum PlaybackCessationMode {
PLAYBACK_CESSATION_MODE_UNKNOWN = 0;

// On video completion or when terminated by user
COMPLETION_OR_USER = 1;

// On leaving viewport or when terminated by user
LEAVING_OR_USER = 2;

// On leaving viewport continues as a floating/slider unit until
// video completion or when terminated by user
LEAVING_CONTINUES_OR_USER = 3;
}
optional PlaybackCessationMode playback_cessation_mode = 19 [default =
PLAYBACK_CESSATION_MODE_UNKNOWN];

// Types of feed for audio content. See
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list--feed-types-
// for details.
enum FeedType {
FEED_TYPE_UNKNOWN = 0;

// Music streaming service.
MUSIC_SERVICE = 1;

// Live content broadcast over the air but also available through online
// streaming.
FM_AM_BROADCAST = 2;

// Original, pre-recorded content distributed as episodes in a series.
PODCAST = 3;
}

// Type of audio content feed where an audio ad can be played.
optional FeedType feed_type = 21 [default = FEED_TYPE_UNKNOWN];

// Options for delivery of audio or video content. See
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/AdCOM%20v1.0%20FINAL.md#list_deliverymethods
// for details.
enum ContentDeliveryMethod {
CONTENT_DELIVERY_METHOD_UNKNOWN = 0;

// Content is transferred continuously by the network; clients receive
// real-time content for playback while connected. Example: broadcast TV.
STREAMING = 1;

// Content is transferred incrementally as client's playback requires.
// Example: on-demand movies, podcasts, or music.
PROGRESSIVE = 2;

// Content should be transferred completely prior to use/playback.
// Example: content downloaded to the user's device for offline
// consumption.
DOWNLOAD = 3;
}

// Supported delivery methods for the video or audio content where an ad can
// be shown.
repeated ContentDeliveryMethod delivery_method = 22 [packed = true];

// Indicates that this bid request is fetching impressions in advance of a
// future ad break in a live video stream. The impression may not be
// rendered if, for example, the user closes the video player before the ad
// break begins. The bid request for the same opportunity may also be
// retried in some cases, such as updated publisher settings.
optional bool prefetch = 25;
}
optional Video video = 29;

// The publisher settings list id that applies to this page.
// See the RTB Publisher Settings guide at
// https://developers.google.com/authorized-buyers/rtb/pub-settings-guide
// for details.
optional fixed64 publisher_settings_list_id = 42;

// Publisher type of the inventory where the ad will be shown. For a given
// request, publisher inventory can be either owned and operated (O&O),
// represented by the publisher, or of unknown status.
enum PublisherType {
UNKNOWN_PUBLISHER_TYPE = 0;
PUBLISHER_OWNED_AND_OPERATED = 1;
PUBLISHER_REPRESENTED = 2;
}
optional PublisherType publisher_type = 51 [default = UNKNOWN_PUBLISHER_TYPE];
enum VisibilityState {
VISIBILITY_STATE_UNKNOWN = 0;

// The page is at least partially visible. For example, in the foreground
// tab of a non-minimized window.
VISIBILITY_STATE_VISIBLE = 1;

// The page is not visible to users. For example, when the page is in a
// background browser tab, or in a minimized window.
VISIBILITY_STATE_HIDDEN = 2;
}

// The visibility state of the web page containing the ad slots.
// See https://www.w3.org/TR/page-visibility/.
optional VisibilityState page_visibility = 66 [default =
VISIBILITY_STATE_UNKNOWN];

// Information about a browser window's user activation state. See
// https://html.spec.whatwg.org/multipage/interaction.html#the-useractivation-interface
message UserActivation {
// Indicates whether a user has completed an interaction since page load.
optional bool has_been_active = 1;

// Indicates whether a user is currently interacting with the page.
optional bool is_active = 2;
}

// User activation information from the browser for the current request, if
// the request is for a web page.
optional UserActivation user_activation = 76;

// The set of possible web navigation types that predicate a page load. Each
// of these types may have different performance characteristics. For example,
// users going back and forth might experience a faster site than users
// performing navigation for the first time or submitting forms. See
// https://w3c.github.io/navigation-timing/#dom-performancenavigationtiming-type.
enum NavigationType {
NAVIGATION_TYPE_UNKNOWN = 0;

// Navigation started by clicking a link, entering the URL in the browser's
// address bar, form submission, or initializing through a script operation
// other than reload and back_forward.
NAVIGATION_TYPE_NAVIGATE = 1;

// Navigation is through the browser's reload operation, location.reload(),
// or a Refresh pragma directive like
// <meta http-equiv="refresh" content="300">.
NAVIGATION_TYPE_RELOAD = 2;

// Navigation is through the browser's history traversal operation.
NAVIGATION_TYPE_BACK_FORWARD = 3;

// Navigation is initiated by a prerender hint (deprecated). See
// https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/prerender.
NAVIGATION_TYPE_PRERENDER = 4;
}

// The type of browser navigation that led to the current page. Unset for
// non-web ad requests.
optional NavigationType navigation_type = 77;

// -----------------------------------------------------------
// Information about the adslots on the page.
message AdSlot {
// An arbitrarily assigned slot id that is unique on a given page and
// usually starts counting from 1. You use this to identify which slot to
// bid on in the BidResponse.
required int32 id = 1;

// A stable identifier for the combination of publisher, ad slot, and page.
optional uint64 ad_block_key = 14;

// The width and height in pixels of the allowed ad sizes. Most requests
// allow only a single size, but some allow more than one. Widths and
// heights are at the same index. For example, if the width values are
// [728, 300, 468] and the height values are [90, 250, 60], then the allowed
// formats are 728x90, 300x250, and 468x60.
//
// For VAST video ad requests a single width/height pair specifies the
// Google-detected video player size. If Google cannot detect the player
// size the publisher-provided player size, if available, is used. For
// VAST video ads, this size is informational; there is no restriction on
// the size of the video ad that you can return.
//
// For mobile interstitial ads (including ones where video ads are eligible)
// the first width height pair is the slot size (this is also the video
// player size for VAST video ads). For many interstitials, this is the
// screen size. Subsequent pairs are recommended interstitial ad sizes that
// also meet the requirements for this interstitial.
repeated int32 width = 2;
repeated int32 height = 3;

message FlexibleAdSlotSettings {
optional int32 max_width = 1;
optional int32 max_height = 2;
optional int32 min_width = 3;
optional int32 min_height = 4;
}

// If the adslot is flexible, this contains settings on how the slot
// may be resized.
optional FlexibleAdSlotSettings flexible_adslot_settings = 50;

// The disallowed attribute ids for the ads that can show in this slot. See
// the publisher-excludable-creative-attributes.txt file in the technical
// documentation for a list of ids.
repeated int32 excluded_attribute = 4 [packed = true];

// The allowed vendor types. See the vendors.txt file in the technical
// documentation for a list of ids. This field does not apply to deals with
// block overrides (see
// https://support.google.com/authorizedbuyers/answer/6114194).
repeated int32 allowed_vendor_type = 6 [packed = true];

message ConsentedProvidersSettings {
// Set of IDs corresponding to ad tech providers (ATPs) for whom the
// publisher has specified to Google that its EEA users have given legally
// valid consent to: 1) the use of cookies or other local storage where
// legally required; and 2) the collection, sharing, and use of personal
// data for personalization of ads by an ATP in accordance with Google's
// EU User Consent Policy.
//
// If a publisher is using the IAB Transparency and Consent Framework
// (TCF) v2 to manage user consent, this is the set of ATPs consented
// through the Additional Consent string (see
// https://support.google.com/admanager/answer/9681920 for details about
// Google's Additional Consent mode). ATPs consented through the TCF v2
// consent string are represented in the
// ConsentedProvidersSettings.tcf_consent_string field.
//
// A mapping of ATP ID to ATP name is posted at providers.csv.
repeated int64 consented_providers = 2 [packed = true];

// The web-safe base64-encoded IAB Transparency and Consent Framework
// (TCF) v2 consent string fetched from the publisher's IAB Consent
// Management Platform (CMP). The structure of the string is defined by
// the IAB TCF v2. This field will be populated if the publisher has
// integrated with a CMP for TCF v2 and that CMP indicates that GDPR
// applies to this ad request and provides a valid consent string. See
// https://support.google.com/authorizedbuyers/answer/9789378 for
// additional information about the Google TCF v2 integration.
//
// See the IAB Global Vendor List at
// https://vendor-list.consensu.org/v2/vendor-list.json for details about
// the vendors listed in the consent string.
optional string tcf_consent_string = 3;

// The raw Additional Consent string, which contains a list of certain
// Google Ad Tech Providers (ATPs). These ATPs are not registered with IAB
// TCF v2, but publishers or their Consent Management Providers (CMPs)
// have ensured that certain disclosures are given to, and consents are
// obtained from, end users, as required by Google's EU User Consent
// Policy. This field is only populated with the use of CMPs that are
// integrated with IAB TCF v2. Such CMPs use the raw Additional Consent
// string to indicate vendors that are not registered with IAB, and
// communicate end users' CMP choices to those vendors. The
// consented_providers field contains the set of vendors that mirrors the
// one represented by the additional_consent_string field, which is in the
// raw form. Vendors or any other third-party service providers must not
// create AC strings themselves.
//
// See https://support.google.com/admanager/answer/9681920 for more
// details about this field.
optional string additional_consent_string = 4;
}

// Information about the ad tech providers for whom the publisher has
// specified to Google that its EEA user has consented to the use of their
// personal data for ads personalization in accordance with Google's EU User
// Consent Policy. This field will only be populated when regs_gdpr is true.
optional ConsentedProvidersSettings consented_providers_settings = 42;

// This field will be set to true in either of the two following cases:
// 1. Google receives a valid IAB Transparency and Consent Framework (TCF)
// v2 consent string and the Consent Management Platform indicates that
// GDPR applies to this ad request.
// 2. Google does not receive an IAB TCF v2 consent string and, based on
// information available to Google, this impression will serve to an
// EEA user.
// It does not constitute legal guidance on GDPR. This field is equivalent
// to Regs.ext.gdpr in Google OpenRTB.
optional bool regs_gdpr = 43;

// This field will be set to true when, based on information available to
// Google, this impression will serve to a user in Brazil. See
// https://storage.googleapis.com/adx-rtb-dictionaries/lgpd-providers.csv
// for the list of ad tech providers that are allowed to
// serve on LGPD-enforced requests.
//
// See https://support.google.com/authorizedbuyers/answer/9928204 for more
// information on LGPD.
optional bool regs_lgpd = 54;

// Contains the Global Privacy Platform's consent string. See the Global
// Privacy Platform specification for more details:
// https://github.com/InteractiveAdvertisingBureau/Global-Privacy-Platform
optional string gpp_consent_string = 81;

// Array of the section(s) of the GPP string which should be applied for
// this transaction. Generally will contain one and only one value, but
// there are edge cases (e.g. a CMP cannot determine a single section ID)
// where more than one may apply. GPP Section 3 (Header) and 4 (Signal
// Integrity) do not need to be included. See IAB-GPP spec for details:
// https://github.com/InteractiveAdvertisingBureau/Global-Privacy-Platform/blob/main/Sections/Section%20Information.md#section-ids
repeated int32 gpp_section_ids = 82 [packed = true];

// The disallowed sensitive ad categories. See the
// ad-sensitive-categories.txt file in the technical documentation for a
// list of ids. You should enforce these exclusions if you have the ability
// to classify ads into the listed categories. This field does not apply to
// deals with block overrides (see
// https://support.google.com/authorizedbuyers/answer/6114194).
repeated int32 excluded_sensitive_category = 7 [packed = true];

// The allowed restricted ad categories for private and open auctions. See
// the ad-restricted-categories.txt file in the technical documentation for
// a list of ids. These only apply for private and open auction bids. See
// the allowed_restricted_category_for_deals field for preferred deals or
// programmatic guarantees. If you bid with an ad in a restricted category,
// you MUST ALWAYS declare the category in the bid response regardless of
// the values in this field.
repeated int32 allowed_restricted_category = 16 [packed = true];

// The allowed restricted ad categories for preferred deals or programmatic
// guarantees. See the ad-restricted-categories.txt file in the technical
// documentation for a list of ids. These only apply for preferred deals or
// programmatic guarantees. See the allowed_restricted_category field for
// private and open auctions. In some cases, restricted categories are only
// allowed on preferred deals or programmatic guarantees, so this field
// lists all categories in allowed_restricted_category, and additionally,
// restricted categories that are only allowed for preferred deals or
// programmatic guarantees. If you bid with an ad in a restricted category,
// you MUST ALWAYS declare the category in the bid response regardless of
// the values in this field.
repeated int32 allowed_restricted_category_for_deals = 22 [packed = true];

// List of creative languages allowed by the publisher. The order is
// arbitrary. The codes are 2 or 5 characters and are documented at
// https://developers.google.com/google-ads/api/data/codes-formats#languages.
// When not set, all languages are allowed.
repeated string allowed_languages = 27;

// The disallowed ad product categories. See the ad-product-categories.txt
// file in the technical documentation for a list of ids. You should enforce
// these exclusions if you have the ability to classify ads into the listed
// categories. This field does not apply to deals with block overrides (see
// https://support.google.com/authorizedbuyers/answer/6114194).
repeated int32 excluded_product_category = 13 [packed = true];

// Block list of applications by their platform-specific exchange
// independent application identifiers. On Android, these should
// be bundle or package names (for example, com.foo.mygame).
// On iOS, these are numeric IDs.
// Bids with ads that advertise any app from this list will be filtered
// out before the auction.
repeated string excluded_app_ids = 66;

// A creative that is disallowed to bid on this impression due to Ad
// Exchange policies or creative disapproval, excluded creative attributes,
// excluded product or sensitive categories, allowed vendor types,
// restricted categories or languages applicable to the bid request.
message ExcludedCreative {
// Buyer creative ID of the disallowed creative.
optional string buyer_creative_id = 1;
}

// Creatives that are disallowed for the impression. Submitting a bid with
// one of the creatives in this list will result in such bid being filtered
// before the auction. Contact your account manager if you would like
// to enable this feature.
repeated ExcludedCreative excluded_creatives = 18;

// Whether the adslot is only eligible for deals bids. Bids for the open
// auction will be filtered when this field is set to true. Bidders can bid
// on the open auction or deals when this field is set to false.
optional bool only_deal_bids_accepted = 49;

// Information about the pre-targeting configs that matched.
message MatchingAdData {
// The billing ids corresponding to the pretargeting configs that matched.
repeated int64 billing_id = 2 [packed = false];

// The minimum CPM value that you can bid to not be filtered before the
// auction. This may be a global minimum, or it may be a minimum set by
// the publisher. The value is in micros of the bidding currency.
// The bidding currency is determined by:
// 1. The bidder-level currency, if configured.
// 2. Otherwise, the currency of the buyer accounts indicated by the
// billing IDs in the billing_id field.
optional int64 minimum_cpm_micros = 5;

// Information about any deals that matched for this inventory.
message DirectDeal {
// An id identifying the deal.
optional int64 direct_deal_id = 1;

// For deal_type=PREFERRED_DEAL or deal_type=PROGRAMMATIC_GUARANTEED,
// you must bid at least fixed_cpm_micros (in micros of the bidding
// currency) in order to participate in the deal. If you win, you will
// be charged fixed_cpm_micros. For deal_type=PRIVATE_AUCTION or
// deal_type=AUCTION_PACKAGE or deal_type=MARKETPLACE_PACKAGE, you must
// bid at least fixed_cpm_micros. Bidding higher CPM than
// fixed_cpm_micros will increase your chance to win when
// deal_type=PRIVATE_AUCTION or deal_type=AUCTION_PACKAGE or
// deal_type=MARKETPLACE_PACKAGE, however it will not increase your
// chance to win for other types of deals. The bidding currency is
// determined by:
// 1. The bidder-level currency, if configured.
// 2. Otherwise, the currency of the buyer accounts indicated by the
// billing IDs in the billing_id field.
optional int64 fixed_cpm_micros = 2;

// The type of the deal. Note that Authorized Buyers policy overrides
// apply to all Programmatic Guaranteed and Preferred Deal bids, and do
// not apply to bids for other deal types.
enum DealType {
UNKNOWN_DEAL_TYPE = 0;

// Bids are fixed-price and evaluated before the Open Auction. Bidders
// are not required to bid with Preferred Deals when they are present
// on the bid request. See
// https://support.google.com/authorizedbuyers/answer/2604595 for more
// information.
PREFERRED_DEAL = 1;

// Bids participate in a Private Auction against a select list of
// buyers with specific floors. See
// https://support.google.com/authorizedbuyers/answer/2839853 for more
// information.
PRIVATE_AUCTION = 2;

// Bids are fixed-price and evaluated before the Open Auction. Bidders
// are expected to bid with Programmatic Guaranteed deals whenever
// they are present on a bid request in order to ensure that the
// number of impressions agreed upon for a given deal are served. See
// https://support.google.com/authorizedbuyers/answer/7174589 for more
// information.
PROGRAMMATIC_GUARANTEED = 3;

// The deal ID is an identifier for a collection of Open Auction
// inventory matching a given set of targeting criteria. See
// https://support.google.com/authorizedbuyers/answer/7516884 for more
// information.
AUCTION_PACKAGE = 4;

// Package of inventory that a publisher makes available to either all
// buyers or selected bidders. Bids participate in auction in the same
// way as private auction candidates. See
// https://support.google.com/authorizedbuyers/answer/12817370 for
// more information.
MARKETPLACE_PACKAGE = 5;
}
optional DealType deal_type = 3 [default = UNKNOWN_DEAL_TYPE];

// Whether the publisher has exempted this deal from configured blocks.
// This setting does not override AdX policies or Ad Review Center
// decisions.
optional bool publisher_blocks_overridden = 4 [default = false];

// Experimental field; subject to change.
// An enum declaring the host of the creative, which will only be
// populated for Programmatic Guaranteed deals.
// Currently, this field should only ever be set to
// CREATIVE_SOURCE_ADVERTISER.
enum CreativeSourceType {
CREATIVE_SOURCE_UNKNOWN = 0;

// The creative is hosted by the advertiser, which means the bidder
// is required to provide a creative in the bid response.
CREATIVE_SOURCE_ADVERTISER = 1;

// The creative is hosted by the publisher, which means the bidder
// does not need to include a creative in the bid response.
// For more information on publisher-hosted creatives, see
// https://support.google.com/admanager/answer/9243220.
// This feature isn't currently supported for RTB bidders.
CREATIVE_SOURCE_PUBLISHER = 2;
}
optional CreativeSourceType creative_source = 16 [default =
CREATIVE_SOURCE_ADVERTISER];

// This field is only applicable to Programmatic Guaranteed deals. The
// buyer is allowed to skip bidding on the impression if this field is
// false. When it is true, the buyer is required to bid on this deal for
// this impression opportunity.
optional bool must_bid = 9 [default = true];

// Constraints for creatives that can apply when bidding on a deal.
message CreativeConstraints {
// The allowed ad types of the deal. If empty, there are no
// deal-specific allowed ad type restrictions for the deal. In that
// case, bidders should refer to the BidRequest-level creative types
// in adslot.allowed_ad_types.
repeated AllowedAdType allowed_ad_types = 1 [packed = true];

// Whether skippable creatives are allowed. For
// PROGRAMMATIC_GUARANTEED or PREFERRED_DEAL deals that specifically
// allow video or audio ad types, it is always set. For the
// skippability setting of other deal types or open auction bidding,
// refer to the corresponding BidRequest-level field
// video.video_ad_skippable.
optional Video.SkippableBidRequestType video_ad_skippable = 2 [default
= ALLOW_SKIPPABLE];

// The maximum allowed duration in milliseconds for the ad. For
// PROGRAMMATIC_GUARANTEED or PREFERRED_DEAL deals that specifically
// allow video or audio ad types, it is always set. For the allowed
// max duration of other deal types or open auction bidding, refer to
// the corresponding BidRequest-level field video.max_ad_duration.
optional int32 max_ad_duration_ms = 3;
}

// Creative constraints for this deal. If this is not set, bidders
// should refer to the BidRequest-level setting of each field.
optional CreativeConstraints creative_constraints = 17;

// If non-empty, this field contains a list of seat IDs in the bidder's
// namespace set by media planners that are allowed by the publisher to
// bid on this deal. All seat IDs not included in this list are blocked
// from bidding on this deal. Bids on this deal on behalf of other
// seats, as indicated by the BidResponse.ad.adslot.seat_id field, and
// bids with no seat ID will be filtered before the auction. If this
// field is empty, there are no restrictions on the seat IDs that can
// bid on this deal.
repeated string allowed_seat_ids = 18;
}
repeated DirectDeal direct_deal = 6;
}
repeated MatchingAdData matching_ad_data = 9;

// If non-empty, this field contains a list of seat IDs in the bidder's
// namespace set by media planners that are blocked by the publisher. Any
// bids on behalf of a blocked seat, as indicated by the
// BidResponse.ad.adslot.seat_id field, will be filtered before the auction.
// If this field is non-empty, allowed_seat_ids will be empty. If this field
// and allowed_seat_ids are both empty, there are no seat ID restrictions
// for this request.
repeated string blocked_seat_ids = 67;

// If non-empty, this field contains a list of seat IDs in the bidder's
// namespace set by media planners that are allowed by the publisher. All
// seat IDs not included in this list are blocked. Bids on behalf of other
// seats, as indicated by the BidResponse.ad.adslot.seat_id field, and bids
// with no seat ID will be filtered before the auction. If this field is
// non-empty, blocked_seat_ids will be empty. If this field and
// blocked_seat_ids are both empty, there are no seat ID restrictions for
// this request.
repeated string allowed_seat_ids = 68;

// The publisher settings list ids that apply to this slot. See the RTB
// Publisher Settings guide at
// https://developers.google.com/authorized-buyers/rtb/pub-settings-guide
// for details.
repeated fixed64 publisher_settings_list_id = 15;

// Parameters related to exchange bidding (third party exchanges doing
// real-time bidding on DFP). This is never populated in calls to AdX
// real-time bidders.
message ExchangeBidding {
// Repeated KeyValue pairs to be sent from the publisher to the
// exchange bidder.
repeated KeyValue key_value = 3;
}
optional ExchangeBidding exchange_bidding = 28;

// Parameters related to Open Bidding.
message OpenBidding {
// This field is set to true if the publisher set up a yield group or a
// mediation group that targets this adslot and this bidder. See
// https://support.google.com/admanager/answer/7128453 for information on
// Open Bidding and its effects on the bidding process.
optional bool is_open_bidding = 2;
}
optional OpenBidding open_bidding = 53;

// AdUnitMapping is used to identify publisher inventory units in the
// bidder's namespace. The mappings are only populated when
// the bidder works directly with a publisher, and provides the mapping
// from Google's ad unit namespace to the bidder's inventory namespace.
// The ad unit mapping is only applicable for requests that use a custom
// SDK. https://support.google.com/admanager/answer/9601810.
message AdUnitMapping {
// Key-value pair used to specify the inventory unit in the bidder's
// namespace.
message Keyval {
// The key is the name of the bidder's inventory unit identifier for the
// SDK.
optional string key = 1;

// The value of the bidder's inventory unit identifier for the given
// format.
optional string value = 2;
}

// Multiple key-value pairs can be specified in order to support
// bidders whose inventory unit space is hierarchical and has multiple
// identifiers. The key-value pairs for the chosen AdUnitMapping should be
// sent back in the bid response as
// BidResponse.ad.sdk_rendered_ad.sdk_params. This is passed to the
// bidder's SDK.
repeated Keyval keyvals = 1;

// Possible ad unit formats that can be used for the mapping. Corresponds
// to the adapter that will be used on the SDK.
enum FormatType {
FORMAT_UNKNOWN = 0;

// Display banner ads for web or mobile apps. For example, a 320x50
// leaderboard slot. This includes out-stream video.
FORMAT_BANNER = 1;

// A full-screen ad to be displayed inside a mobile app.
FORMAT_INTERSTITIAL = 2;

// Custom display or video ads for web or mobile apps that match the
// user experience of the site or app in which they’re placed.
FORMAT_NATIVE = 3;

// Video ads that appear before, during, or after video content
// streams.
FORMAT_VIDEO_VAST = 4;

// Video ads for mobile apps that allow users to voluntarily watch an
// ad in exchange for an in-app reward.
FORMAT_REWARDED = 5;

// Interstitial ads that allow users to watch an ad in exchange for
// an in-app reward. Does not require opt-in.
// https://support.google.com/admanager/answer/7386053
FORMAT_REWARDED_INTERSTITIAL = 6;

// App open ads shows at app load screens. App open ads can be closed
// at any time, and are designed to be shown when the users bring the
// app to the foreground.
FORMAT_APP_OPEN = 7;
}

// The mappings are targeted through a format, which is expressed in the
// Google-defined taxonomy. Format is populated in the bid request since
// Google supports targeting multiple formats with a single ad
// unit, and Google's definition of the format may not match the bidder's
// definition. In order for the bidder to differentiate which format
// matched, it is sent in the bid request.
optional FormatType format = 2;
}

// Ad unit mappings that match the given adslot.
repeated AdUnitMapping ad_unit_mapping = 64;

// Indicates the creative policy and publisher blocks that applies to this
// request.
message CreativeEnforcementSettings {
// Creative policy enforcement level that applies to this request.
// Creatives that don't adhere to the specified policy will be filtered
// before the auction. The status of the creatives with their respective
// policies can be retrieved through Creative API.
// https://developers.google.com/authorized-buyers/apis/guides/rtb-api/creatives
// Bids on deals may override the policy enforcement applicable to the
// request.
enum PolicyEnforcement {
POLICY_ENFORCEMENT_UNKNOWN = 0;

// Baseline policy for all ads serving through any of Google's ads
// platform products. Learn more at:
// https://support.google.com/platformspolicy/answer/3013851.
POLICY_ENFORCEMENT_PLATFORM_POLICY = 1;

// Policy for ads serving through Google's ad network. This includes the
// baseline policy for all ads serving through any of Google's ads
// platform products. Learn more at:
// https://support.google.com/authorizedbuyers/answer/1325008.
POLICY_ENFORCEMENT_NETWORK_AND_PLATFORM_POLICY = 2;
}
optional PolicyEnforcement policy_enforcement = 1;

// Creative publisher blocks enforcement level that applies to this
// request. Publisher blocks allow publishers to control which creatives
// can be shown on their properties.
// Deals may also override publisher blocks. Refer to adslot.
// matching_ad_data.direct_deal.publisher_blocks_overridden field.
enum PublisherBlocksEnforcement {
PUBLISHER_BLOCKS_ENFORCEMENT_UNKNOWN = 0;

// The publisher's blocking controls are enforced on creatives
// submitted. Publisher blocks enforcement settings are provided in the
// following fields:
// - publisher_settings_list_id
// - excluded_sensitive_category
// - allowed_restricted_category
// - excluded_product_category
// - allowed_vendor_type
// - excluded_attribute
PUBLISHER_BLOCKS_ENFORCEMENT_APPLIES = 1;

// The publisher's blocking controls are not enforced on creatives
// submitted.
PUBLISHER_BLOCKS_ENFORCEMENT_OVERRIDDEN = 2;
}
optional PublisherBlocksEnforcement publisher_blocks_enforcement = 3;
}
optional CreativeEnforcementSettings creative_enforcement_settings = 58;

// The ad unit code (https://support.google.com/admanager/topic/4426071)
// This is currently only set for exchange bidding requests.
optional string dfp_ad_unit_code = 33;

// Visibility information for the slot.
enum SlotVisibility {
NO_DETECTION = 0;
ABOVE_THE_FOLD = 1;
BELOW_THE_FOLD = 2;
}
optional SlotVisibility slot_visibility = 12 [default = NO_DETECTION];

// Viewability percentage for the ad slot. This is an estimate of the
// likelihood that this slot will be viewable by the end user based on
// historical and environment data. It is expressed as a percentage in the
// range of [0, 100]. The default value -1 indicates that viewability could
// not be estimated.
optional int32 viewability = 21 [default = -1];

// Historical click-through rate for ads served in the ad slot. This is
// expressed as a fraction in the range [0.0, 1.0]. The default value of
// -1.0 indicates that historical click-through rate data is not available.
// This figure does not include data aggregated from Google Ads. The
// click-through rate can vary for a given ad slot throughout the day.
optional float click_through_rate = 25 [default = -1];

// Historical completion rate for video ads served in the ad slot. This is
// expressed as a fraction in the range [0.0, 1.0]. The default value of
// -1.0 indicates that historical completion rate data is not available.
// This field is only applicable to video inventory, and does not include
// data aggregated from Google Ads.
optional float video_completion_rate = 30 [default = -1];

// iFraming state of the ad slot on the webpage where it is present.
enum IFramingState {
UNKNOWN_IFRAME_STATE = 0;
NO_IFRAME = 1;
SAME_DOMAIN_IFRAME = 2;
CROSS_DOMAIN_IFRAME = 3;
}
optional IFramingState iframing_state = 19 [default = UNKNOWN_IFRAME_STATE];

// iFrame depth of the ad slot on the webpage where it is present.
// Currently only set for video ad requests.
enum IFramingDepth {
UNKNOWN_IFRAME_DEPTH = 0;
NOT_IN_IFRAME = 1;
ONE_IFRAME = 2;
MULTIPLE_IFRAME = 3;
}
optional IFramingDepth iframing_depth = 20 [default = UNKNOWN_IFRAME_DEPTH];

// A native ad consists of pieces that are rendered by the publisher. A
// publisher may support multiple distinct native ad templates. If the
// request also allows banners or videos, you can respond with other types
// of ads by setting html_snippet or video_url instead. If only native
// templates exist, you must set the native_ad field in any response you
// send.
message NativeAdTemplate {
// Bitfield describing which fields are required by the publisher. Bid
// responses with no value for these fields will be rejected. Click and
// view tracking urls are always implicitly required.
optional int64 required_fields = 1;

// Bitfield describing which fields are recommended by the publisher. All
// recommended fields are supported, but not all recommended fields are
// required.
optional int64 recommended_fields = 2;

// max_safe_length indicates the maximum number of Unicode characters that
// are guaranteed to be shown without truncation. Longer strings may be
// truncated and ellipsized by Ad Exchange or the publisher during
// rendering.
optional int32 headline_max_safe_length = 3;
optional int32 body_max_safe_length = 4;
optional int32 call_to_action_max_safe_length = 5;
optional int32 advertiser_max_safe_length = 6;
optional int32 price_max_safe_length = 15;

// The width and height from which to calculate the required aspect ratio.
// You can provide a larger image in the response. Images that have aspect
// ratios substantially different than those implied by the height and
// width may be filtered.
optional int32 image_width = 7;
optional int32 image_height = 8;
optional int32 logo_width = 9;
optional int32 logo_height = 10;
optional int32 app_icon_width = 11;
optional int32 app_icon_height = 12;

// Globally distinct id for the specific style, HTML, and CSS with which
// the native ad is rendered.
optional int32 style_id = 16;

// Type of style layout for each native ad template.
enum LayoutType {
PIXEL = 0;
FLUID = 1;
}
optional LayoutType style_layout_type = 17 [default = PIXEL];

// If the style_layout_type is Pixel, width and height of the
// entire native ad after rendering. If the style_layout_type is
// Fluid, the style_height and style_width may optionally
// not be populated.
optional int32 style_height = 18;
optional int32 style_width = 19;

// Defines the bits used in required_fields and recommended_fields. There
// is one bit for each of the fields in BidResponse.Ad.NativeAd
enum Fields {
NO_FIELDS = 0;
HEADLINE = 1;
BODY = 2;
CALL_TO_ACTION = 4;
ADVERTISER = 8;
IMAGE = 16;
LOGO = 32;
APP_ICON = 64;
STAR_RATING = 128;
PRICE = 256;
DEPRECATED_STORE = 512;
VIDEO = 1024;
}
}
repeated NativeAdTemplate native_ad_template = 51;

// NativePlacementType describes placement of native ad slot with respect to
// surrounding context.
enum NativePlacementType {
PLACEMENT_UNKNOWN = 0;

// In the feed of content - for example as an item inside the organic
// feed/grid/listing/carousel.
PLACEMENT_IN_FEED = 1;

// In the atomic unit of the content - for example, in the article page or
// single image page.
PLACEMENT_ATOMIC_UNIT = 2;

// Outside the core content - for example in the ads section on the right
// rail, as a banner-style placement near the content, or another
// placement type.
PLACEMENT_OUTSIDE = 3;

// Recommendation widget, most commonly presented below the article
// content.
PLACEMENT_RECOMMENDATION = 4;
}
optional NativePlacementType native_placement_type = 45 [default =
PLACEMENT_UNKNOWN];

// Whether the ad request has been determined to come directly from the
// publisher.
enum MediationStatus {
UNKNOWN = 0;
DIRECT_REQUEST = 1;
}
optional MediationStatus mediation_status = 52 [default = UNKNOWN];

// Auto refresh settings.
message AutoRefresh {

message AutoRefreshSettings {
enum AutoRefreshType {
UNKNOWN_AUTO_REFRESH_TYPE = 0;

// Refresh triggered by user-initiated action such
// as scrolling.
USER_ACTION = 1;

// Event-driven content change. For example, ads refresh
// when the football game score changes on the page.
EVENT = 2;

// Time-based refresh. Ads refresh on a predefined time
// interval even without user activity.
TIME = 3;
}

// The type of the declared auto refresh.
optional AutoRefreshType refresh_type = 1 [default =
UNKNOWN_AUTO_REFRESH_TYPE];

// The minimum refresh interval. This applies to all refresh types.
optional int32 min_refresh_interval_seconds = 2;
}

// The auto-refresh settings that the publisher has on this
// inventory. This is repeated because publishers may
// do multiple types of auto refresh on one piece of inventory.
repeated AutoRefreshSettings refresh_settings = 1;

// The number of times this ad slot had been refreshed since last page
// load.
optional int32 refresh_count = 2 [default = 0];
}
optional AutoRefresh auto_refresh = 23;

// Stickiness settings declared by the publisher.
message StickySettings {
// Specifies the allowable sticky settings values.
enum Stickiness {
UNKNOWN_STICKINESS = 0;
IS_STICKY = 1;
}

// Whether the ad slot is a sidebar that sticks on screen when user
// scrolls.
optional Stickiness vertical_stickiness = 1 [default =
UNKNOWN_STICKINESS];

// Whether the ad slot is a horizontal slot that sticks on the top of the
// screen when user scrolls.
optional Stickiness top_horizontal_stickiness = 2 [default =
UNKNOWN_STICKINESS];

// Whether the ad slot is a horizontal slot that sticks on the bottom of
// the screen when user scrolls.
optional Stickiness bottom_horizontal_stickiness = 3 [default =
UNKNOWN_STICKINESS];
}
optional StickySettings sticky_settings = 31;

// Sources for non-browser inventory.
enum NonBrowserSource {
UNDECLARED_SOURCE = 0;
DESKTOP_APP = 1;
}

// Publisher declaration stating that this ad slot may serve on
// non-browser inventory, like desktop apps.
optional NonBrowserSource non_browser_slot_source = 34 [default =
UNDECLARED_SOURCE];

// Defines who controls the environment that made the ad request and will
// render the ad. On platforms where code written by Google will handle
// the ad this field is set to GOOGLE. When this field is PUBLISHER the
// publisher has placed their own code on the device to handle playback of
// the ad. There is no technical difference in how these request are
// handled. You may use this field to differentiate between different
// environments for non-technical reasons. This field is only set for
// requests that allow VAST video ads.
enum Renderer {
UNKNOWN_RENDERER = 0;
GOOGLE = 1;
PUBLISHER = 2;
}
optional Renderer renderer = 26 [default = UNKNOWN_RENDERER];

// Whether this request is for an Accelerated Mobile Page (AMP). AMP HTML
// pages load faster, by restricting parts of HTML, CSS and Javascript. For
// more information on how AMP ads render, refer to the AMP ads README:
// https://github.com/ampproject/amphtml/blob/master/ads/README.md
enum AmpAdRequestType {
// AMP status unknown. Request may or may not be from an AMP page.
UNKNOWN_AMP = 0;

// Not an AMP page. Could be regular HTML, VAST video, or other context.
NON_AMP_PAGE = 1;

// Late-loading request from an AMP HTML page. Ad will render with a
// slight delay so it will not negatively impact page render performance.
AMP_PAGE_LATE_REQUEST = 2;
}
optional AmpAdRequestType amp_ad_request_type = 29 [default = NON_AMP_PAGE];

// Whether this is an AMP page or not.
enum AmpPage {
// AMP page status unknown.
UNKNOWN_AMP_PAGE = 0;

// This is not an AMP page.
DIALECT_HTML = 1;

// This is an Amp page.
DIALECT_HTML_AMP = 2;
}
optional AmpPage is_amp_page = 38;

// Possible requirement types for AMP ads.
enum AmpAdRequirementType {
// AMP ad requirements unknown.
UNKNOWN_AMP_AD_REQUIREMENT_TYPE = 0;

// AMP ads are not allowed.
AMP_AD_NOT_ALLOWED = 1;

// Either AMP ads or non-AMP ads are allowed;
// AMP ads are not early rendered.
AMP_AD_ALLOWED_AND_NOT_EARLY_RENDERED = 2;

// Either AMP ads or non-AMP ads are allowed;
// AMP ads are early rendered.
AMP_AD_ALLOWED_AND_EARLY_RENDERED = 3;

// AMP ads are required.
// Ads that are non-AMP may be rejected by the publisher.
AMP_AD_REQUIRED = 4;
}
optional AmpAdRequirementType amp_ad_requirement_type = 39;

// Whether the user receives a reward for viewing the ad. For video ads,
// typical implementations allow users to read an additional news article
// for free, receive an extra life in a game, or get a sponsored ad-free
// music session. The reward is typically distributed after the video ad is
// completed.
optional bool is_rewarded = 32 [default = false];

// Possible ad types that are allowed in the bid response. allowed_ad_types
// always contains one or more values. Interstitial slots may also support
// banner ads. An ad slot with ALLOWED_AD_TYPE_NATIVE may or may not support
// native video, regardless of whether ALLOWED_AD_TYPE_VIDEO is set.
// Likewise, an ad slot without ALLOWED_AD_TYPE_NATIVE does not support
// native video, regardless of whether ALLOWED_AD_TYPE_VIDEO is set.
enum AllowedAdType {
UNKNOWN_ALLOWED_AD_TYPE = -1;
ALLOWED_AD_TYPE_BANNER = 0;
ALLOWED_AD_TYPE_NATIVE = 1;
ALLOWED_AD_TYPE_VIDEO = 2;
ALLOWED_AD_TYPE_AUDIO = 3;
}
repeated AllowedAdType allowed_ad_types = 36 [packed = true];

// Total number of impressions served to this user (within this specific
// site or app) in this browsing session, plus 1. A session ends after 30
// minutes inactivity. The default value of -1 indicates that the session
// depth cannot be estimated.
optional int32 session_depth = 40 [default = -1];

// Secure signals passed by the publisher.
message SecureSignal {
// The source (provider) of the signal. Identifier for the library or SDK
// that generated this data.
optional string source = 4;

// The secure signal.
optional string data = 2;
}
repeated SecureSignal secure_signals = 41;

// Possible ad rendering API frameworks that can be supported.
// If an API is not explicitly listed, it is assumed not to be supported.
enum APIFramework {
UNKNOWN_FRAMEWORK = 0;

// Mobile Rich Media Ad Interface Definitions Version 1.0. See
// https://www.iab.com/guidelines/mraid/.
MRAID_1 = 3;

// Mobile Rich Media Ad Interface Definitions Version 2.0. See
// https://www.iab.com/guidelines/mraid/.
MRAID_2 = 5;

// Mobile Rich Media Ad Interface Definitions Version 3.0. See
// https://www.iab.com/guidelines/mraid/.
MRAID_3 = 6;

// Open Measurement Interface Definition Version 1.0. See
// https://iabtechlab.com/standards/open-measurement-sdk/.
OMID_1 = 7;
}

// List of supported API frameworks for this impression.
repeated APIFramework api = 46 [packed = true];

// Deprecated. This will be removed in Q1 2024. This field has been
// deprecated in favor of the repeated field
// `billable_event_rate_bid_adjustment` below.
// For ads rendered using a custom SDK only: multiplier applied to bid in
// the auction. The adjustment reflects the likelihood that your bid would
// generate a billable event (meaning the ad renders successfully) if
// it won the auction, relative to the probability that other bids generate
// a billable event if they won the auction. This adjustment can be larger
// or smaller than 1. This affects the final ranking in the auction only; in
// particular, this multiplier does not affect the payment.
optional double billable_event_rate_adjustment = 59 [deprecated = true,
default = 1];

// The billable event rate bid adjustment of an ad and the dependent
// features of the ad the adjustment applies to, such as the format or the
// SDK used to render the ad. Each feature combination may have a unique
// adjustment, each adjustment therefore specifies which SDK or creative
// format it applies to.
message BillableEventRateBidAdjustment {
// A multiplier to your bid to adjust for the likelihood that your bid
// would result in a billable event (namely, the ad renders successfully)
// if it won the auction, relative to the average probability that bids
// from other buyers would result in a billable event if they won the
// auction. This adjustment can be larger or smaller than 1. This affects
// the final ranking in the auction only; in particular, this multiplier
// does not affect the payment or whether the bid clears any floor price.
optional float bid_adjustment = 1 [default = 1];

// The types of creative the bid adjustments can apply to.
enum CreativeType {
CREATIVE_TYPE_UNKNOWN = 0;

// Banner ads
HTML_SNIPPET = 1;

// VAST video or audio ads
VIDEO_VAST = 2;

// Native ads
NATIVE = 3;

// SDK rendered ad
SDK_RENDERED = 4;
}

// The type of ads to which the above bid adjustment applies to. Each type
// corresponds to different ways of how the ad's creative is specified, as
// described in
// https://developers.google.com/authorized-buyers/rtb/response-guide#specify-creative.
// If the ad is SDK-rendered, this will be set to SDK_RENDERED regardless
// of the actual creative type.
optional CreativeType creative_type = 2 [default = CREATIVE_TYPE_UNKNOWN];

// The SDK used to render the ad with. The SDK ID will match the one sent
// in BidRequest.mobile.installed_sdk.id. This field is not set for Google
// SDK.
optional Mobile.InstalledSdk sdk = 3;
}

// A list of billable event rate bid adjustments applicable to the request
// and the ad features associated to the adjustment. Bid adjustments are
// listed here only if they are not equal to 1.0, which is equivalent to
// having no adjustment. This field replaces the deprecated field
// billable_event_rate_adjustment.
repeated BillableEventRateBidAdjustment billable_event_rate_bid_adjustment =
65;

// Identifier of the OM SDK integration. For more info, see the OpenRTB
// Advisory for Open Measurement SDK:
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/OpenRTB%20support%20for%20OMSDK.md#openrtb-and-adcom.
optional string omidpn = 56;

// Version of the OM SDK integration. For more info, see the OpenRTB
// Advisory for Open Measurement SDK:
// https://github.com/InteractiveAdvertisingBureau/AdCOM/blob/master/OpenRTB%20support%20for%20OMSDK.md#openrtb-and-adcom.
optional string omidpv = 57;

// Describes the environment where the ad auction is run.
enum AuctionEnvironment {
// The auction determining the winning ad is held server-side.
SERVER_SIDE_AUCTION = 0;

// The contextual auction that determines a winning contextual bid is held
// server-side, and bidding functions are run on the device to determine
// interest group bids. Both the winning contextual bid and interest
// group bids are entered into a final auction held on the device to
// select the winning ad. For more information regarding the Protected
// Audience API, see:
// https://github.com/WICG/turtledove and
// https://github.com/WICG/turtledove/blob/main/FLEDGE.md
ON_DEVICE_INTEREST_GROUP_AUCTION = 1;

// The contextual auction that determines a top-ranked contextual bid is
// held server-side, and the bidding logic to determine interest group
// bids and the scoring logic to determine the final winning ad among
// interest group bids and the top contextual bid runs are executed in
// Bidding and Auction servers. See more detail in
// https://github.com/privacysandbox/fledge-docs/blob/main/bidding_auction_services_api.md
SERVER_SIDE_INTEREST_GROUP_AUCTION = 3;
}

// Specifies where the ad auction runs.
// Deprecated. This will be removed in November, 2023. Use
// supported_auction_environment instead.
optional AuctionEnvironment auction_environment = 61 [deprecated = true,
default = SERVER_SIDE_AUCTION];

// The supported auction environment for this impression. For inventory
// which does not support interest group bidding, this will always be set to
// SERVER_SIDE_AUCTION. For inventory which does support interest group
// bidding, this will be set to ON_DEVICE_INTEREST_GROUP_AUCTION. Note that
// this only indicates that the interest group auction is supported, not
// that it is guaranteed to execute. If no buyer chooses to participate in
// the interest group auction, then the interest group auction will be
// skipped and the winner of the contextual auction, if any, will be
// served instead.
optional AuctionEnvironment supported_auction_environment = 69 [default =
SERVER_SIDE_AUCTION];

// Indicates whether interest group bidding is allowed for the bidder.
// Depending on account settings and other factors, a bidder might be
// disallowed from submitting interest group bids, even though an interest
// group auction may ultimately decide the winning ad.
optional bool interest_group_bidding_allowed = 70;

// Experimental feature; may be subject to change.
// Reach out to your account manager to use Protected Audience API.
//
// When interest group bidding is allowed for the bidder
// (interest_group_bidding_allowed = true),
// this message contains information about the on-device auction.
message InterestGroupAuction {
// The adslot size for the Protected Audience API on-device interest
// group bids.
// The on-device interest group winning bid will be expected to fill this
// slot size.
// Note that this size may be different from the sizes for the contextual
// request (Adslot.width and Adslot.height). The contextual request may
// have multiple sizes; however, the on-device auction is expected to
// fill only a single fixed slot size.
optional int32 width = 1;
optional int32 height = 2;

// Indicates whether the winner of the interest group auction will be
// rendered. If true, then the on-device auction winner will be rendered
// and the impression can be billable. If false, the top-ranked contextual
// bid will be rendered, and the on-device auction winner will be ignored
// and not result in a rendered, billable impression.
optional bool render_interest_group_ads = 3;

// Indicates whether the on-device auction for the current request was
// parallelized.
//
// To learn more about parallelized auctions, see
// https://developers.google.com/authorized-buyers/rtb/protected-audience-api#parallelization
optional bool parallelized = 4;

// Interest group buyer-specific information related to parallelized
// Protected Audience API auctions.
message ParallelAuctionBuyer {
// The origin of the interest group buyer which was included
// in the parallelized auction.
//
// If a ParallelAuctionBuyer entry for a particular origin is
// included in the `parallel_auction_buyer` list, then that origin was
// included in the parallelized auction and a corresponding buyer
// trusted server call was made for that origin. If a buyer
// origin is not included but `parallelized` is true, then it
// cannot participate in the current client-side auction. However,
// bidders can indicate interest in participating in future Protected
// Audience API auctions by including valid InterestGroupBuyer(s) in
// `BidResponse.adslot.interest_group_bidding.interest_group_buyers`.
// Those interest group buyers will be eligible for future parallelized
// requests from the same browser instance and domain.
optional string origin = 1;
}

// Parallel auction data for each of the bidder's interest group buyer(s)
// that was included in the current request's parallel auction.
repeated ParallelAuctionBuyer parallel_auction_buyer = 5;

// Allowed ad types for interest group bids. This may be a subset of the
// allowed ad types for contextual bids, as indicated by
// BidRequest.adslot.allowed_ad_types, because interest group bidding may
// support fewer ad formats than contextual bidding in some cases.
repeated AllowedAdType allowed_ad_types = 6 [packed = true];
}
optional InterestGroupAuction interest_group_auction = 62;

// The expected time period when an impression can occur in seconds
// following a winning bid. The impression may be billable only if it serves
// within this time. To learn more about impression expiration, see the
// following guide:
// https://developers.google.com/authorized-buyers/rtb/billing-event-guide
optional int32 impression_expiration_seconds = 63;

// The name of the rendering environment, such as a mobile ads or video
// SDK, or a publisher ad tag type. This field describes a Google SDK while
// the installed_sdk field describes third party SDKs.
optional string display_manager = 71;

// Version of the rendering environment specified by the display_manager
// field. This field describes a Google SDK while the installed_sdk field
// describes third party SDKs.
optional string display_manager_version = 72;
}
repeated AdSlot adslot = 14;

// Feedback on bids submitted in previous responses. This is only set if
// real-time feedback is enabled for your bidder. Contact your account
// manager if you want to enable real-time feedback.
message BidResponseFeedback {
// The unique id from BidRequest.id
optional bytes request_id = 1;

// The index of the BidResponse_Ad if there was more than one. The index
// starts at zero for the first creative.
optional int32 creative_index = 2;

// The status code for the ad. See creative-status-codes.txt in the
// technical documentation for a list of ids.
optional int32 creative_status_code = 3;

// If the bid won the auction, this is the price paid in your account
// currency. If the bid participated in the auction but was out-bid, this
// is the CPM that should have been exceeded in order to win. This is not
// set if the bid was filtered prior to the auction, if the publisher or
// winning bidder has opted out of price feedback or if your account has
// opted out of sharing winning prices with other bidders. For first-price
// auctions, minimum_bid_to_win is populated instead of this field.
optional int64 cpm_micros = 4;

// The minimum bid value necessary to have won the auction, in micros of
// your account currency. If your bid won the auction, this is the second
// highest bid that was not filtered (including the floor price). If your
// bid did not win the auction, this is the winning candidate's bid. This
// field will only be populated if your bid participated in a first-price
// auction, and will not be populated if your bid was filtered prior to the
// auction.
optional int64 minimum_bid_to_win = 7;

// The minimum bid value necessary to have won the server-side component of
// the overall auction given that there was also an interest group bidding
// component to the overall auction which ran using the Protected Audience
// API. The value is expressed in CPM micros of the buyer account currency.
// The minimum bid to win for the overall auction, including bids from the
// server-side and the on-device interest group components, is populated in
// the minimum_bid_to_win field of the same BidResponseFeedback object.
optional int64 server_side_component_minimum_bid_to_win = 16;

// Billable event rate multiplier that was applied to this bid during
// ranking. The adjustment reflects the likelihood that your bid would
// generate a billable event (namely, the ad renders successfully) if it won
// the auction, relative to the probability that other bids generate a
// billable event if they won the auction. This adjustment can be larger or
// smaller than 1. This affects the final ranking in the auction only; in
// particular, this multiplier does not affect the payment or whether the
// bid clears any floor price.
optional float billable_event_rate_bid_adjustment = 15 [default = 1];

// When a publisher uses an RTB auction and waterfall-based SDK mediation on
// the same query, the winner of the real-time auction must also compete in
// a mediation waterfall (which is ordered by price) to win the impression.
// If the bid participated in the auction and there was no waterfall, the
// value of this field is 0. If the bid participated in the auction and
// there was a waterfall, the value of this field is a price representing a
// sample bid from the eligible mediation networks that were higher than the
// auction winner, weighted by expected fill rate. This field can be used
// in conjunction with minimum_bid_to_win to train bidding models. The CPM
// is in micros of your account currency.
optional int64 sampled_mediation_cpm_ahead_of_auction_winner = 10;

// Event notification token that was included in the bid response.
optional bytes event_notification_token = 5;

// Buyer creative ID that was included in the bid response.
optional string buyer_creative_id = 6;

// Possible types of bid response feedback objects.
enum FeedbackType {
FEEDBACK_TYPE_UNSPECIFIED = 0;

// Feedback for a bid that was submitted on a bid response.
BID_FEEDBACK = 1;

// Feedback for an interest group buyer submitted on a bid response to
// particpate in an interest group bidding component of the auction run
// using the Protected Audience API.
INTEREST_GROUP_BUYER_FEEDBACK = 2;
}

// The type of the BidResponseFeedback message. Google will send separate
// BidResponseFeedback objects for:
// a) Each bid submitted on a bid response
// b) Each buyer submitted on a bid response to particpate in an interest
// group bidding component of the auction run using the Protected Audience
// API.
optional FeedbackType feedback_type = 17;

// Origin of an interest group buyer that was included in the bid response.
// This field is populated only for feedback where a bidder opted in an
// interest group buyer to participate in the interest group bidding
// component of the overall auction run using the Protected Audience API.
// To learn more about origins, see https://www.rfc-editor.org/rfc/rfc6454.
// To learn more about interest group bidding and the Protected Audience
// API, see
// https://developers.google.com/authorized-buyers/rtb/fledge-origin-trial.
optional string buyer_origin = 18;

// The status code for the submitted interest group buyer. This field is
// only populated in the feedback for an interest group buyer that a bidder
// requested to enter into the interest group auction through the bid
// response. Individual creative status codes of bids submitted by the buyer
// in the on-device interest group auction are not available. See
// https://storage.googleapis.com/adx-rtb-dictionaries/interest-group-buyer-status-codes.txt
// for a list of interest group buyer status codes.
optional int32 interest_group_buyer_status_code = 19;
}
repeated BidResponseFeedback bid_response_feedback = 44;

// How many milliseconds Google will wait for a response before ignoring it.
optional int32 response_deadline_ms = 57;

// -----------------------------------------------------------
// Testing options.
//
// If true, then this is a test request. Results will not be displayed to
// users and you will not be billed for a response even if it wins the
// auction. You should still do regular processing since the request may be
// used to evaluate latencies or for other testing. During your initial
// testing with Google traffic any response that you make will be filtered
// out of the auction whether this option has a value of true or false.
optional bool is_test = 15 [default = false];

// If true, then this request is intended to measure network latency.
// Return an empty BidResponse with only processing_time_ms set as quickly as
// possible without executing any bidding logic.
optional bool is_ping = 17 [default = false];

// If true, then the callout model predicted that you will not bid
// on this request. We send a sampled percentage of such requests so that we
// can automatically update the model when bidding patterns change.
optional bool is_predicted_to_be_ignored = 45 [default = false];

// SupplyChain object. For more information, see
// https://github.com/InteractiveAdvertisingBureau/openrtb/blob/master/supplychainobject.md.
message SupplyChain {
// Indicates whether the chain contains all nodes involved in the
// transaction leading back to the owner of the site, app or other medium of
// the inventory.
optional bool complete = 1;

message SupplyChainNode {
// The canonical domain name of the SSP, Exchange, Header Wrapper, etc
// system that bidders connect to. This may be the operational domain of
// the system, if that is different than the parent corporate domain, to
// facilitate WHOIS and reverse IP lookups to establish clear ownership of
// the delegate system. This should be the same value as used to identify
// sellers in an ads.txt file if one exists.
optional string advertising_system_identifier = 1;

// The identifier associated with the seller or reseller account within
// the advertising system. This must contain the same value used in
// transactions, specifically the publisher_id field in the Google
// protocol. Should be limited to 64 characters in length.
optional string seller_identifier = 2;

// Indicates whether this node will be involved in the flow of payment for
// the inventory. When set to true, the advertising system in the
// advertising_system_identifier field pays the seller in the
// seller_identifier field, who is responsible for paying the previous
// node in the chain. When set to false, this node is not involved in the
// flow of payment for the inventory.
optional bool handles_payment = 6;
}

// Array of SupplyChainNode objects in the order of the chain. In a complete
// supply chain, the first node represents the initial advertising system
// and seller ID involved in the transaction, for example, the owner of the
// site, app, or other medium. In an incomplete supply chain, it represents
// the first known node. The last node represents the entity sending this
// bid request.
repeated SupplyChainNode nodes = 2;

// Version of the supply chain specification in use, in the format of
// "major.minor". For example, for version 1.0 of the spec, use the string
// "1.0".
optional string version = 3;
}
optional SupplyChain supply_chain = 69;

// Experimental feature; may be subject to change. See
// https://support.google.com/authorizedbuyers/answer/10890762 for more
// information.
//
// Describes the scope of frequency cap enforcement available for this
// request. Frequency caps to be enforced for a bid can be specified in the
// BidResponse.ad.adslot.frequency_cap field.
enum FrequencyCappingScope {
// Default value which should not be used, or which can indicate that
// frequency cap scope could not be reliably determined.
FREQUENCY_CAPPING_SCOPE_UNKNOWN = 0;

// Frequency capping based on bid response specifications is not available
// for this request. A frequency-capped bid for a bid request with no
// frequency cap availability will be filtered prior to the auction.
FREQUENCY_CAPPING_SCOPE_NONE = 1;

// Frequency capping enforcement is available across multiple sites within
// the same browser.
FREQUENCY_CAPPING_SCOPE_BROWSER = 2;

// Frequency capping enforcement is available across multiple apps on the
// device, excluding browsers.
FREQUENCY_CAPPING_SCOPE_DEVICE = 3;

// Frequency capping enforcement is available within a single app.
FREQUENCY_CAPPING_SCOPE_APP = 4;

// Frequency capping enforcement is available within a single site.
FREQUENCY_CAPPING_SCOPE_SITE = 5;
}
optional FrequencyCappingScope frequency_capping_scope = 70;

// Contains labels indicating the experiment or control groups that are
// active for this request. Work with your account manager to opt in to an
// experiment. The exact set of experiments available, their meaning, and
// whether there is any action required from the bidder varies from experiment
// to experiment and will be communicated separately.
//
// If empty, then this request is not part of any experiment or control group,
// or your bidder is not participating in any experiments.
repeated string experiment_ids = 78;

// The Digital Services Act (DSA) transparency requirements. See
// https://support.google.com/admanager/answer/14335032.
message Dsa {
// Values indicating whether DSA declarations should be included in the bid
// response and, if so, whether or not the publisher is an Online Platform
// (OP) or Very Large Online Platform (VLOP), as defined by the DSA.
enum DsaSupport {
DSA_SUPPORT_UNKNOWN = 0;

// DSA declarations are not required in the bid response.
NOT_REQUIRED = 1;

// DSA declarations are supported, but not required in the bid response.
SUPPORTED = 2;

// DSA declarations are required in the bid response.
REQUIRED = 3;

// DSA declarations are required in the bid response and the publisher is
// an OP or VLOP.
REQUIRED_BY_ONLINE_PLATFORM = 4;
}

// Indicates if DSA declarations should be included in the bid response.
// Bids where DSA declarations are required but not included will not be
// accepted.
optional DsaSupport dsa_support = 1;

// Options describing a publisher's ability to render DSA transparency
// declarations.
enum PublisherRenderingSupport {
PUBLISHER_RENDERING_SUPPORT_UNKNOWN = 0;

// Publisher can't render.
PUBLISHER_UNABLE_TO_RENDER = 1;

// Publisher could render depending on the buyer's rendering capability as
// described in the BidResponse.ad.dsa_transparency.buyer_render field.
PUBLISHER_CAN_RENDER = 2;

// Publisher will render regardless of the buyer's rendering capability as
// described in the BidResponse.ad.dsa_transparency.buyer_render field.
PUBLISHER_WILL_RENDER = 3;
}

// Indicates if the publisher will render the DSA Transparency info. This
// will signal if the publisher is able to and intends to render the icon
// or other appropriate user-facing symbol and display the DSA transparency
// info to the end user.
optional PublisherRenderingSupport publisher_rendering_support = 2;

// Options describing if a publisher requires DSA transparency declarations.
enum DataToPublisher {
DATA_TO_PUBLISHER_UNKNOWN = 0;

// Do not send transparency data.
DO_NOT_SEND = 1;

// Optional to send transparency data.
OPTIONAL = 2;

// Send transparency data.
SEND = 3;
}

// Indicates whether the bidder should provide DSA transparency declarations
// in the bid response. A publisher may need this information for audit or
// other purposes, even if they will not render the transparency
// declarations themselves.
optional DataToPublisher data_to_publisher = 3;
}

// The Digital Services Act (DSA) transparency information requirements.
optional Dsa dsa = 86;
}

// This is the message that you return in response to a BidRequest. You may
// specify zero or more ads. For each ad, you should provide an ad slot on
// which the ad can run. An ad slot is identified by the AdSlot.id from the
// BidRequest. If you do not want to bid, submit a response with no ads and
// with only the processing_time_ms set.
message BidResponse {

message Ad {
// The event notification token is sent to AdX by bidders for
// troubleshooting. AdX will include the token in real-time feedback for the
// bid. The content of the token will not be logged by AdX. AdX will ignore
// any token longer than 128 bytes.
optional bytes event_notification_token = 25;

// A unique identifier chosen by you for the creative in this response.
// This must always be set, must be limited to at most 64 bytes, and must be
// a valid UTF8 string. Every buyer_creative_id you use must always be
// associated with the same creative. This field is used to communicate
// approval statuses when issues are found. Do not specify the same id for
// different creatives, or all creatives will be disapproved if a problem
// with a single creative is found. Do not specify different ids for the
// same creative in different responses or no creatives will be served since
// approval status is assigned on a per-id basis.
optional string buyer_creative_id = 10;

// Only one of the following should be set:
// 1) html_snippet, 2) video_url, 3) native_ad, or 4) sdk_rendered_ad.
//
// The HTML snippet that will be placed on the web page to display the ad.
// Use BidResponse.Ad.AdSlot.billing_id to indicate which billing id
// this snippet is attributed to.
optional string html_snippet = 1;

// The URL to fetch a video ad. The URL should return an XML response that
// conforms to the VAST 2.0 or 3.0 standard. Use
// BidResponse.Ad.AdSlot.billing_id to indicate which billing id to
// attribute this ad to. Only one of the following should be set:
// html_snippet, video_url. Only set this field if the BidRequest is for an
// in-video ad (BidRequest.video is present).
optional string video_url = 9;

// The VAST document to be returned. This document should conform to the
// VAST 2.0 or 3.0 standard. Use BidResponse.Ad.AdSlot.billing_id to
// indicate which billing ID to attribute this ad to.
// Only set this field if the BidRequest is for an in-video ad and the
// response is VAST XML.
optional string video_vast_xml = 24;

// The URL to fetch an AMPHTML ad. Only one of the following should be set:
// html_snippet, video_url, amp_ad_url, native_ad.
optional string amp_ad_url = 23;

// The content of a native ad. Native ads consist of multiple building
// blocks, which are rendered by the publisher. Only one of the following
// should be set: html_snippet, video_url, or native_ad.
// Only set this field if the BidRequest is for a native ad
// (BidRequest.adslot.native is present).
message NativeAd {
// A video in the form of either a URL for a VAST tag, or an in-line VAST
// tag. Only set this field if VIDEO is required or recommended in the
// BidRequest's NativeAdTemplate.
oneof video {
// The URL to fetch a video ad. The URL should return an XML response
// that conforms to VAST standards.
string video_url = 13;

// The VAST document to be returned. Max size is 100kB.
string video_vast_xml = 16;
}

// A short title for the ad.
optional string headline = 1;

// A long description of the ad.
optional string body = 2;

// A label for the button that the user is supposed to click
optional string call_to_action = 3;

// The name of the advertiser or sponsor, to be displayed in the ad
// creative.
optional string advertiser = 4;

message Image {
optional string url = 1;

// Image width and height are specified in pixels. You may provide a
// larger image than was requested, so long as the aspect ratio is
// preserved.
optional int32 width = 2;
optional int32 height = 3;
}

// A large image.
optional Image image = 5;

// A smaller image, for the advertiser's logo.
optional Image logo = 6;

// The app icon, for app download ads.
optional Image app_icon = 7;

// The app rating in the app store. Must be in the range [0-5].
optional double star_rating = 8;

// The URL that the browser/SDK will load when the user clicks the ad.
// This can be the landing page directly, or the first step of a redirect
// chain that eventually leads to it. For backward compatibility, if this
// is not set, the first Ad.click_through_url is used.
optional string click_link_url = 14;

// This field is deprecated in favor of the repeated click_tracking_urls
// field at the BidResponse.Ad level. It will be removed at the end of
// Q2 2022.
// The URL to use for click tracking. The SDK pings click tracking url on
// a background thread. When resolving the url, HTTP 30x redirects are
// followed. The SDK ignores the contents of the response; this URL
// has no effect on the landing page for the user.
optional string DEPRECATED_click_tracking_url = 11 [deprecated = true];

// This field is deprecated in favor of the click_tracking_urls
// field at the BidResponse.Ad level. It will be removed at the end of
// Q2 2022.
// The URLs to use for click tracking. This will be used throughout the
// serving stack and will incorporate any URL in click_tracking_url.
repeated string DEPRECATED_click_tracking_urls = 15 [deprecated = true];

// The price of the promoted app including the currency info.
optional string price = 10;
}
optional NativeAd native_ad = 18;

// The set of destination URLs for the snippet. This includes the URLs that
// the user will go to if they click on the displayed ad, and any URLs that
// are visible in the rendered ad. Do not include intermediate calls to the
// adserver that are unrelated to the inal landing page. A BidResponse that
// returns a snippet or video ad but declares no click_through_url will be
// discarded. Only set this field if html_snippet or video_url or native_ad
// are set. This data is used as a destination URL declaration, for example
// for post-filtering of publisher-blocked URLs or ad categorization.
//
// For non-native ads, it is not used for click tracking or any
// other ad functionality; it is only used as a destination URL
// declaration.
//
// For native ads, if NativeAd.click_link_url is not set, the first
// value of click_through_url is used to direct the user to the landing
// page. In addition, all values are used as destination
// URL declarations (similar to the non-native case).
repeated string click_through_url = 4;

// All vendor types for the ads that may be shown from this snippet. You
// should only declare vendor ids listed in the vendors.txt file in the
// technical documentation. We will check to ensure that the vendors you
// declare are in the allowed_vendor_type list sent in the BidRequest for
// AdX publishers.
repeated int32 vendor_type = 5;

// All attributes for the ads that may be shown from this snippet. See
// buyer-declarable-creative-attributes.txt in the technical documentation
// for a list of ids. We will check to ensure none of these attributes are
// in the excluded_attribute list in the BidRequest.
repeated int32 attribute = 6;

// All sensitive categories for the ads that may be shown from this snippet.
// See ad-sensitive-categories.txt in the technical documentation for a list
// of ids. We will check to ensure none of these categories were in the
// excluded_sensitive_category list in the BidRequest.
repeated int32 category = 7;

// All restricted categories for the ads that may be shown from this
// snippet. See ad-restricted-categories.txt in the technical documentation
// for a list of ids. We will check to ensure these categories were listed
// in the allowed_restricted_category list in the BidRequest. If you are
// bidding with ads in restricted categories you MUST ALWAYS declare them
// here.
repeated int32 restricted_category = 17;

// All names of the ad's advertisers.
repeated string advertiser_name = 11;

// The width and the height in pixels of the ad. Setting these is optional.
// However, these must be set if the bid BidRequest.AdSlot has more than one
// width and height or if BidRequest.Mobile.is_interstitial_request is true.
optional int32 width = 14;
optional int32 height = 15;

message AdSlot {
// The slot id from the BidRequest that the ad may appear in.
required int32 id = 1;

// The maximum CPM you want to be charged if you win the auction for this
// ad slot, expressed in micros of the specified currency or default
// bidding currency. For example, to bid a CPM of 1.29 USD, set
// max_cpm_micros = 1290000. Winning bids are rounded up to billable
// units. For example, in USD, bids are rounded up to the next multiple
// of 10,000 micros (one cent).
required int64 max_cpm_micros = 2;

// The minimum CPM you want to be charged if you win the auction for this
// ad slot, expressed in micros of the specified currency or default
// bidding currency. This may represent a second price if you choose
// max_cpm_micros as the highest of several bids, or some form of reserve
// price if you want to override the reserve price set by the publisher.
// The bid must be less than or equal to max_cpm_micros or it will be
// ignored. This field is optional and does not need to be set. This
// field is not applicable when responding to bid requests with
// auction_type set to FIRST_PRICE.
optional int64 min_cpm_micros = 3;

// The currency used by max_cpm_micros and min_cpm_micros, using ISO-4217
// alpha codes. If this field is populated, the specified currency will
// be used to interpret the bid. Otherwise, the default bidding currency
// will be used, which is determined in the following priority:
// 1. The bidder-level currency, if configured in RTB account settings.
// 2. The buyer-level currency. The buyer will be determined by the
// billing ID specified in the billing_id field of the bid response if it
// is populated, otherwise it will be based on the sole billing ID sent
// in the bid request.
//
// The currency of a buyer account is set on account creation and can be
// checked by contacting a Technical Account Manager.
optional string currency = 15;

// Billing id to attribute this impression to. The value must be in the
// set of billing ids for this slot that were sent in the
// BidRequest.AdSlot.matching_ad_data.billing_id. This must always be set
// if the BidRequest has more than one
// BidRequest.AdSlot.matching_ad_data.billing_id or if the bidder has
// active child seats.
optional int64 billing_id = 4;

// The deal id that you want this bid to participate in. Leave unset
// or set it to "1" if a deal is available but you want to
// ignore the deal and participate in the open auction.
optional int64 deal_id = 5 [default = 0];

// For exchange bidders (third party exchanges doing real-time bidding on
// DFP), the deal id from the exchange's namespace that is associated with
// this bid and reported to publishers. Leave unset if there is no
// associated deal. This is arbitrary UTF8 text and must be at most 64
// bytes.
optional string exchange_deal_id = 6;

// When exchange_deal_id is set, the type of deal. This is reported to
// publishers and affects how the deal is treated in the auction.
enum ExchangeDealType {
OPEN_AUCTION = 0;
PRIVATE_AUCTION = 1;
PREFERRED_DEAL = 2;
EXCHANGE_AUCTION_PACKAGE = 3;
}
optional ExchangeDealType exchange_deal_type = 7 [default = OPEN_AUCTION];

// The seat ID in the bidder's namespace representing the seat on whose
// behalf this bid was made.
optional string seat_id = 25;

// Buyer declared ID which will be used to break down cost transparency
// metrics in Reporting. Note that IDs with fewer than 1000 impressions
// will not be used to break down metrics. IDs longer than 64 bytes will
// be ignored.
optional string buyer_reporting_id = 8;

// Token used to identify end third party buyer information if an
// exchange as an open bidder is an intermediary. This is obtained from
// the third party buyer and must be passed to Google unaltered in the bid
// response.
optional string third_party_buyer_token = 12;

// Experimental feature; may be subject to change. See
// https://support.google.com/authorizedbuyers/answer/10890762 for more
// information.
//
// Specifies frequency capping to be applied to the bid. Impressions for
// each user are capped at the level specified by frequency_cap_id. A bid
// will not participate in the auction if an additional impression for the
// user would violate any of the specified caps. Multiple frequency caps
// can be specified for the same frequency_cap_id.
//
// A bid is filtered before the auction if the frequency cap is malformed.
// Instances where the cap is malformed include:
// - frequency_cap_id is empty or is very long
// - max_mpressions or time_range are non-positive
// - there are a large number of frequency caps for a single bid
// - time_unit is not specified
//
// Note that if a subsequent bid with the same frequency_cap_id uses a
// different duration (represented by time_unit and time_range) then
// impressions counted against the old frequency cap will not count
// against the new one, and the impressions counted against the new
// frequency cap with a different time_unit and time_range will not count
// against the old frequency cap..
message FrequencyCap {
// An ID that can represent a bidder's use-case for frequency capping.
// For example, it could represent their campaign, ad, line item, or
// some other entity. It should not contain any user-specific
// information or identifiers and should not be longer than 64
// characters.
optional string frequency_cap_id = 1;

// The time units for which frequency caps can be enforced.
enum TimeUnit {
UNKNOWN_TIME_UNIT = 0;
MINUTE = 1;
DAY = 2;
WEEK = 3;
MONTH = 4;

// When INDEFINITE is used, time_range will be ignored. INDEFINITE
// means the frequency cap will be applied for a long period of time,
// (longer than a month) but not necessarily forever.
INDEFINITE = 5;
}

// The unit of time used to specify the time window for which a
// frequency cap applies.
optional TimeUnit time_unit = 2;

// The length of the time window, in units specified by time_unit, for
// which the frequency cap applies. For instance, if time_unit=WEEK and
// time_range=3, then capping is applied for a three week period. If the
// time_unit=INDEFINITE, this will be ignored.
optional int32 time_range = 3 [default = 1];

// The maximum number of impressions allowed to be shown to a user for
// the provided frequency_cap_id within the time window described by
// time_unit and time_range.
optional int32 max_impressions = 4;
}
repeated FrequencyCap frequency_cap = 16;

// Position within the pod.
enum PodPosition {
// Any position in the pod.
POD_POSITION_ANY = 0;

// Last position in the pod.
POD_POSITION_LAST = 1;

// First position in the pod.
POD_POSITION_FIRST = 2;

// First or last position in the pod.
POD_POSITION_FIRST_OR_LAST = 3;
}

// Indicates that the bid is only eligible
// for a specific position within the pod.
optional PodPosition position_in_pod = 22;

// All bids with the same bid_group_id will be won or lost as a group.
// Bids must have a non-empty bid_group_id to allow an ad to be played
// as part of a pod.
// This field is currently only supported for rewarded video pods
// requests. If an ad is submitted on multiple positional bids
// represented by AdSlot messages, each bid (AdSlot message)
// must have a different bid_group_id.
// For example, if a bidder wants to bid ad_1 for first position
// and last position in the pod and ad_2 for any position and
// want to ensure either both win at the same time or neither of those
// wins, bidder needs to submit:
// ad {
// buyer_creative_id: "ad_1",
// adslot {
// position_in_pod: POD_POSITION_FIRST,
// bid_group_id: "group1"
// },
// adslot {
// position_in_pod: POD_POSITION_LAST,
// bid_group_id: "group2"
// }
// },
// ad {
// buyer_creative_id: "ad_2",
// adslot {
// position_in_pod: POD_POSITION_ANY,
// bid_group_id: "group1"
// },
// adslot {
// position_in_pod: POD_POSITION_ANY,
// bid_group_id: "group2"
// }
// }
optional string bid_group_id = 23;
}
repeated AdSlot adslot = 3;

// The URL to call when the bid wins the auction. Note that the win notice
// URL is different from an impression tracking URL because winning an
// auction does not necessarily result in rendering an impression.
optional string win_notice_url = 34;

// The URLs to call when the impression is rendered. This is supported for
// all inventory types and all formats.
repeated string impression_tracking_url = 19;

// The URL to call when the bid is filtered before the auction, or lost the
// auction.
optional string loss_notice_url = 35;

// The URLs to call when the user clicks on the ad. Currently supported only
// for native ads and Programmatic Guaranteed deals with publisher-
// managed creatives. In the publisher managed case, these click trackers
// will be sent to the bidder server to server. In all other cases, these
// will be sent from the user's device. For more information on
// publisher-managed creatives, see
// https://support.google.com/admanager/answer/9243220.
repeated string click_tracking_urls = 30;

// Link to ad preferences page. This is only supported for native ads.
// If present, a standard AdChoices icon is added to the native creative and
// linked to this URL.
optional string ad_choices_destination_url = 21;

message ImpressionTrackingResource {
// The URL of a Javascript resource. The URLs should not contain script
// tags. For example: "https://mycdn.com/tracker.js".
optional string script_url = 1;

// Additional context provided for rendering.
enum Context {
UNKNOWN_CONTEXT = 0;

// Currently not supported.
OMID = 1;
}
repeated Context context = 2;

// Parameters associated with the resource that will be passed to the
// resource when it is loaded. The format of the parameters is dependent
// on the script vendor.
optional string verification_parameters = 3;

// Used to uniquely identify the verification script provider.
optional string vendor_key = 4;
}

// Resources to invoke when the impression is rendered. This is supported
// for native and banner formats only and explicitly allowed scripts
// only.
repeated ImpressionTrackingResource impression_tracking_resource = 26;

// An ad that will be rendered by an SDK known to the buyer. This can only
// be used when the BidRequest included a mobile.installed_sdk submessage.
message SdkRenderedAd {
// The identifier for the SDK that will render the ad. Must match a
// mobile.installed_sdk.id sent in the corresponding bid request.
optional string id = 1;

// Data to pass to the SDK in order to render the ad. This data is opaque
// to the publisher and to Google.
optional string rendering_data = 2;

// Declared ad assets to support creative scanning, classification, and
// enforcement of ad policy and publisher blocks for ads rendered with a
// custom SDK.
message DeclaredAd {
// Ad content used by SDK to render an ad.
oneof content {
// The HTML snippet representative of the SDK-rendered ad.
string html_snippet = 1;

// The URL to the VAST asset used in the SDK-rendered ad.
string video_url = 2;

// The VAST document used to render custom SDK-rendered ad. This
// document should conform to the VAST 2.0 or 3.0 standard.
string video_vast_xml = 5;

// The content of a native ad. Native ads consist of multiple building
// blocks (such as image and text), which are rendered by the buyer
// SDK.
NativeAd native_ad = 6;
}

// The final landing pages of the SDK-rendered ad.
repeated string click_through_url = 4;
}
optional DeclaredAd declared_ad = 6;
}
optional SdkRenderedAd sdk_rendered_ad = 27;

// Advertiser's SKAdNetwork information to support app installation
// attribution for iOS 14 and later. Apple's SKAdNetwork API helps
// advertisers measure ad-driven app installation by sending a postback
// to the ad network after a successful install. Ad networks will need
// to send their network ID and signed advertiser information to allow
// an install to be attributed to the ad impression.
// For more info visit:
// https://developer.apple.com/documentation/storekit/skadnetwork
message SKAdNetworkResponse {
// Version of SKAdNetwork supported by the advertiser. Also used to
// specify how the signature was generated by the advertiser. This
// should match the version from BidRequest.mobile.skad.version.
optional string version = 1;

// Ad network identifier used in signature. This should match one of the
// items in BidRequest.mobile.skad.skadnetids.
optional string network = 2;

// Campaign ID compatible with Apple's spec. Used in SKAdNetwork 3.0 and
// below. Replaced by Source Identifier (`source_identifier` field) in
// SKAdNetwork 4.0 and above.
optional int64 campaign = 3;

// A four-digit integer that ad networks define to represent the ad
// campaign. Used in SKAdNetwork 4.0+ and replaces the `campaign` field.
optional int64 source_identifier = 11;

// ID of advertiser's app in Apple's app store.
optional string itunesitem = 4;

// ID of custom product page to display (for iOS 15 or later).
// If not specified, default product page will be displayed.
// See https://developer.apple.com/app-store/custom-product-pages/
// for more details about custom product pages.
optional string product_page_id = 12;

// SKAdNetwork API starting from version 2.2 supports multiple ad
// presentation options specified by the `fidelity-type` parameter of the
// SKAdNetwork signature. This holds parameters used to generate the
// signature that would be different for each fidelity type supported.
// For more info visit:
// https://developer.apple.com/documentation/storekit/skadnetwork/signing_and_providing_ads
message Fidelity {
// The fidelity type of the attribution to track.
optional SKAdNetworkFidelityType fidelity_type = 1 [default =
STOREKIT_RENDERED_ADS];

// A unique all-lowercase UUID generated by the advertiser to use for
// generating the signature.
optional string nonce = 2;

// Unix time in millis used at the time of signature generation.
optional int64 timestamp = 3;

// SKAdNetwork signature as specified by Apple.
optional string signature = 4;
}
repeated Fidelity fidelities = 9;

// A unique all-lowercase UUID generated by the advertiser to use for
// generating the signature.
// Note: This field will be deprecated in favor of the
// BidResponse.ad.skadn.fidelities.nonce field to support multiple
// fidelity types.
optional string nonce = 5;

// ID of publisher's app in Apple's app store. This should match the ID
// from BidRequest.mobile.skad.sourceapp.
optional string sourceapp = 6;

// Unix time in millis used at the time of signature generation.
// Note: This field will be deprecated in favor of the
// BidResponse.ad.skadn.fidelities.timestamp field to support multiple
// fidelity types.
optional int64 timestamp = 7;

// SKAdNetwork signature as specified by Apple.
// Note: This field will be deprecated in favor of the
// BidResponse.ad.skadn.fidelities.signature field to support multiple
// fidelity types.
optional string signature = 8;

// These options indicate how to present SKOverlay recommending the
// advertised app.
// Supported by iOS 14 and later.
//
// For more info visit:
// https://developer.apple.com/documentation/storekit/skoverlay
message SKOverlay {
// Delay in seconds after the ad begins before presenting the overlay.
// If this field is set to 0, the overlay will be shown immediately
// after the ad begins. If this field is unset, the overlay will not
// be shown for the ad.
optional int32 delay_seconds = 1;

// Delay in seconds after the endcard shows before presenting the
// overlay. (This field only applies to rewarded or interstitial video
// creatives.) If this field is set to 0, the overlay will be shown
// immediately after the endcard shows. If this field is unset,
// the overlay will not be shown for the endcard.
// If both `delay_seconds` and `endcard_delay_seconds` are set,
// the overlay will be automatically dismissed when the ad ends,
// and shown again after the endcard shows.
optional int32 endcard_delay_seconds = 2;

// Whether this overlay can be dismissed by the user.
optional bool dismissible = 3 [default = true];
}
optional SKOverlay skoverlay = 13;

// Google Mobile Ads SDK options for SKAdNetwork handling.
message SKAdNetworkOptions {
// By default, SKAdNetwork attribution will only be initiated if the
// click-through URL lands on the app store, either as a direct link to
// the app store or as the final destination of a server-side redirect
// chain. Enables GMA SDK to always initiate SKAdNetwork
// attribution on-click regardless of the detected click's final
// destination URL. Note that enabling this will launch the app store
// even for clicks that are not meant to open the app store, for example
// clicks on Ad Choices icon. For more info, see:
// https://developers.google.com/authorized-buyers/rtb/skadnetwork
optional bool always_open_appstore = 1 [default = false];
}
optional SKAdNetworkOptions skadn_options = 10;
}
optional SKAdNetworkResponse skadn = 29;

// ID of the advertised app (only for app promotion).
// On Android, this should be a bundle or package name such as
// com.foo.mygame. On iOS, it is a numeric ID.
//
// In addition to this field, set the app_promotion_type field below to take
// advantage of features specific to app promotion types.
optional string advertised_app_id = 32;

// Possible types of app promotion.
enum AppPromotionType {
UNKNOWN_APP_PROMOTION_TYPE = 0;

// For encouraging new users to download and install the advertised app.
// Clicking this ad will show the app store listing as an overlay (for
// supported formats), without leaving the publisher app.
// Click through URL for this ad points to the app store listing.
INSTALLS = 1;

// For re-engaging existing users who have installed the advertised app.
// Click through URL for this ad points to the installed app directly.
ENGAGEMENT = 2;

// Other types of app promotion that do not fall into the categories
// above. No features specific to app promotion types will apply.
OTHER = 3;
}

// Type of the app promotion corresponding to the advertised app specified
// in the advertised_app_id field above.
// If the advertised app is not specified, this field will be ignored.
//
// Setting advertised_app_id field without this field will be treated as if
// this field were set to OTHER.
optional AppPromotionType app_promotion_type = 33;

// Whether to show the full app store listing for advertised_app_id field
// (or skadn.itunesitem field on iOS) within the publisher app, after the
// video playback completes and before the endcard (if any) appears.
// This field only applies to rewarded or interstitial video creatives.
// Contact your account manager if you would like to enable this feature.
optional bool auto_inline_install = 36;

// DSA Ad Transparency declarations. See
// https://support.google.com/admanager/answer/14335032.
message DsaTransparency {
// Free text string describing the name of the advertiser on whose behalf
// the ad is shown. Bids will not be accepted if this value is longer
// than 100 characters.
optional string displayed_on_behalf = 1;

// Free text string describing the advertiser who paid for the ad. Must
// always be included even if it's the same as what is listed in the
// displayed_on_behalf attribute. Bids will not be accepted if this value
// is longer than 100 characters.
optional string paying_entity = 2;

// Indicates that the buyer will render their own DSA transparency
// information inside the creative.
optional bool buyer_render = 3;
}

// DSA Ad Transparency information provided by the buyer.
optional DsaTransparency dsa_transparency = 39;
}
repeated Ad ad = 2;

// If is_test was set in the BidRequest, then you may return debug information
// as plain text in this field. Don't set this field under normal
// conditions, or set it to values longer than 100 characters. You should only
// use this field when asked to do so as part of troubleshooting particular
// problems.
optional string debug_string = 5;

// Set this to the processing time in milliseconds from when you
// received the request to when you returned the response.
optional int32 processing_time_ms = 4;

// An optional, bidder-specified reason for not submitting a bid. This field
// is equivalent to BidResponse.nbr in the OpenRTB protocol and uses the same
// namespace of no-bid reason codes. See
// https://developers.google.com/authorized-buyers/rtb/downloads/no-bid-reasons.txt
// for the full set of no-bid reason codes.
optional int32 no_bid_reason = 6;

// Experimental feature; may be subject to change.
//
// Reach out to your account manager to use Protected Audience API.
//
// Contains information that needs to be specified for participating in the
// interest group auction for a given ad slot.
message InterestGroupBidding {
// ID of ad slot represented by the corresponding AdSlot object in the bid
// request to link information to be used in the interest group auction to
// the specific ad slot.
optional int32 adslot_id = 2;

// Buyer-level information to use in the interest group auction.
message InterestGroupBuyer {
// Origin of the interest group buyer to participate in the
// interest group auction. For more info regarding the origin see:
// https://developer.mozilla.org/en-US/docs/Glossary/Origin
optional string origin = 2;

// Optional buyer-specific signals to pass into the buyer's
// `generateBid()` function as the `perBuyerSignals` argument. This
// object can be in any bidder-defined format that will be transformed
// into a JSON object following Proto3 JSON representation
// (https://developers.google.com/protocol-buffers/docs/proto3#json).
// Can be left empty if no perBuyerSignals signals are required by the
// bidding function.
optional .google.protobuf.Value per_buyer_signals = 1;

// Optional maximum interest group bid price expressed in CPM currency
// micros that a bidder agrees to pay if they win an in-browser interest
// group auction. Actual winning bid in the in-browser auction that
// determines the amount a bidder pays for the impression may be lower
// than this amount. This constraint allows to reduce the risks from
// in-browser auction bids submitted in error or reported due to fraud and
// abuse.
optional int64 max_bid_cpm_micros = 3;

// Currency used for the max_bid_cpm_micros value.
optional string max_bid_currency = 4 [default = "USD"];

// Modes by which the cost of a winning Protected Audience impression can
// be attributed to a billing ID.
enum BillingAttributionMode {
// Unspecified attribution mode. This value should never be used.
BILLING_ATTRIBUTION_MODE_UNSPECIFIED = 0;

// The cost of the impression will be attributed to the billing ID
// indicated by the `billing_id` field. If this mode is chosen and the
// `billing_id` field doesn't contain one of the available billing IDs
// from the bid request, then the interest group buyer won't be
// eligible to participate in the on-device auction.
BID_RESPONSE = 1;

// The billing ID will be specified by the `GoogleBillingId` HTTP query
// parameter in the ad's render URL. If the render URL for the bid
// returned from `generateBid()` doesn't contain a billing ID present on
// the bid request in the query parameter, the submitted bid will be
// filtered from the Protected Audience API auction.
RENDER_URL_PARAMETER = 2;
}

// Specifies the method by which the interest group buyer will select the
// billing ID to attribute spend.
optional BillingAttributionMode billing_attribution_mode = 10;

// Billing ID that the interest group impression will be attributed to.
// If set, the value must be in the set of billing IDs for this impression
// that were sent in BidRequest.ad_slot.matching_ad_data.billing_id. If
// this field is not set, the interest group buyer will be unable to
// participate in the Protected Audience API auction.
optional int64 billing_id = 5;

// Indicates the currency in which interest group bids will be placed. The
// value must be a three digit ISO 4217 alpha currency code (e.g. "USD").
optional string currency = 6;

// Buyer experiment group ID (EGID) to be specified in the trusted
// bidding signals request URL. This experiment ID will be added to the
// `perBuyerExperimentGroupIds` map, keyed by the interest group owner,
// in the `auctionConfig`. See
// https://github.com/WICG/turtledove/blob/main/FLEDGE.md#31-fetching-real-time-data-from-a-trusted-server
optional uint32 buyer_experiment_group_id = 7;

// Render-time buyer signals that will be expanded into the winning
// interest group ad render URL using the
// `deprecatedRenderURLReplacements` auction configuration field for macro
// expansion.
//
// To be eligible for macro replacement, render URLs must contain a macro
// in the form of `${RENDER_DATA_buyer.origin.example_OPTIONAL_SUFFIX}`,
// where `buyer.origin.example` is the origin of the interest group buyer
// specified by the `InterestGroupBuyer.origin` field, and
// `OPTIONAL_SUFFIX` is an optional suffix that can be specified by the
// `RenderingSignals.macro_suffix` field for distinguishing different
// signals. If the `macro_suffix` is omitted, then the macro name will be
// `${RENDER_DATA_buyer.origin.example}`.
//
// See specification in
// https://wicg.github.io/turtledove/#dom-auctionadconfig-deprecatedrenderurlreplacements
message RenderingSignals {
// URL-safe string according to RFC 3986 section 2.3 which will replace
// the macro in the render URL. Each `InterestGroupBuyer` with a non-URL
// safe `data` string will not be allowed to participate in the interest
// group auction.
optional string data = 1;

// Optional macro suffix that will be appended to RENDER_DATA macro
// name to distinguish different signals.
optional string macro_suffix = 2;
}

// List of rendering signals for macro expansion on the winning interest
// group ad render URL, limited to 3 macros per buyer. Each
// `InterestGroupBuyer` with more than 3 rendering signals will not be
// allowed to participate in the interest group auction.
repeated RenderingSignals rendering_signals = 8;

// Indicates that the buyer will render their own DSA transparency
// information inside the creative delivered through the Protected
// Audience API. See https://support.google.com/admanager/answer/14335032.
optional bool dsa_buyer_render = 9;
}

// Interest group buyers that the bidder requests to enter into the
// interest group auction. Interest groups that are owned by a buyer
// without a corresponding entry here will not participate in the auction.
repeated InterestGroupBuyer interest_group_buyers = 3;
}

// Contains information that needs to be specified for participating in the
// interest group auctions.
repeated InterestGroupBidding interest_group_bidding = 10;
}

// SKAdNetwork API starting from version 2.2 supports multiple ad
// presentation options specified by the `fidelity-type` parameter of the
// SKAdNetwork signature. The following are the fidelity types supported by
// Apple. For more info visit:
// https://developer.apple.com/documentation/storekit/skadnetwork/signing_and_providing_ads
enum SKAdNetworkFidelityType {
// Attribution for app installs within 24 hours of viewing an ad for at least
// 3 seconds. Supported for SKAdnetwork version 2.2 and up. For more info see:
// https://developer.apple.com/documentation/storekit/skadnetwork/generating_the_signature_to_validate_view-through_ads
VIEW_THROUGH_ADS = 0;

// Attribution for app installs initiated from the StoreKit-rendered App Store
// product page driven by ad clicks. Supported for all SKAdNetwork versions.
// For more info see:
// https://developer.apple.com/documentation/storekit/skadnetwork/generating_the_signature_to_validate_storekit-rendered_ads
STOREKIT_RENDERED_ADS = 1;
}