Interakcja z określaniem stawek w czasie rzeczywistym rozpoczyna się, gdy Google wyśle do Twojej aplikacji pytanie o stawkę. Z tego przewodnika dowiesz się, jak zakodować aplikację, aby przetwarzała pytanie o stawkę.
Żądanie analizy
Google wysyła pytanie o stawkę jako zserializowany bufor protokołu dołączony jako ładunek binarny żądania POST HTTP. Pole Content-Type
jest ustawione na application/octet-stream
. Przykład znajdziesz w sekcji Przykładowe pytanie o stawkę.
Musisz przeanalizować to żądanie w instancji wiadomości BidRequest
. Wartość BidRequest
jest definiowana w elemencie realtime-bidding.proto
, który można uzyskać ze strony danych referencyjnych. Wiadomość możesz przeanalizować za pomocą metody ParseFromString()
w wygenerowanej klasie BidRequest
. Na przykład ten kod C++ analizuje żądanie z ładunkiem POST w ciągu znaków:
string post_payload = /* the payload from the POST request */; BidRequest bid_request; if (bid_request.ParseFromString(post_payload)) { // Process the request. }
Gdy już będziesz mieć BidRequest
, możesz używać go jako obiektu, wyodrębniając i interpretując potrzebne pola. Na przykład w C++:
for (int i = 0; i < bid_request.adslot_size(); ++i) { const BidRequest_AdSlot& adslot = bid_request.adslot(i); // Decide what to bid on adslot. }
Niektóre informacje wysyłane w funkcji BidRequest
, takie jak identyfikator użytkownika Google, język czy lokalizacja geograficzna, nie zawsze są dostępne. Jeśli masz
grupy reklam z kierowaniem wstępnym, które korzystają z nieznanych informacji w przypadku danego wyświetlenia, nie będą się one zgadzać. Jeśli brakujące informacje nie mają znaczenia w warunkach kierowania wstępnego, pytania o stawkę są wysyłane z pominiętymi informacjami.
Informacje o grupie reklam z kierowaniem wstępnym są dostępne w grupie MatchingAdData
dla każdego elementu AdSlot
. Zawiera on pierwszy pasujący identyfikator grupy reklam z kierowaniem wstępnym, która skłoniła Google do wysłania pytania o stawkę, czyli grupy reklam i kampanii, za które płacisz, gdy Twoja odpowiedź wygra aukcję dla wyświetlenia. W pewnych okolicznościach musisz wyraźnie wskazać w elemencie BidResponse.AdSlot
atrybut billing_id
, np. gdy BidRequest.AdSlot
zawiera więcej niż 1 parametr matching_ad_data
.
Więcej informacji na temat ograniczeń dotyczących treści stawki znajdziesz w realtime-bidding.proto
.
Pliki słownika
Pytanie o stawkę korzysta z identyfikatorów zdefiniowanych w plikach słownika, które są dostępne na stronie danych referencyjnych.
Makra adresu URL stawki
Opcjonalnie niektóre pola BidRequest
można wstawić do adresu URL używanego w żądaniu POST HTTP. Jest to przydatne np. wtedy, gdy używasz prostego frontendu, który równoważy obciążenie względem wielu backendów przy użyciu wartości z żądania. Skontaktuj się z technicznym menedżerem konta, by poprosić o pomoc w zakresie nowych makr.
Makro | Opis |
---|---|
%%GOOGLE_USER_ID%% |
Zastąpione wartością http://google.bidder.com/path?gid=%%GOOGLE_USER_ID%%w momencie żądania zostanie zastąpiony ciągiem znaków http://google.bidder.com/path?gid=dGhpyBhbiBleGFtGxl. Jeśli identyfikator użytkownika Google jest nieznany, w miejsce automatycznie wstawiany jest pusty ciąg znaków o wyniku podobnym do http://google.bidder.com/path?gid= |
%%HAS_MOBILE%% |
Zastępowane poleceniem |
%%HAS_VIDEO%% |
Zastępowana wartością |
%%HOSTED_MATCH_DATA%% |
Zastąpione wartością pola |
%%MOBILE_IS_APP%% |
Zastąpione wartością |
Znajdowanie identyfikatora aplikacji mobilnej na podstawie adresu URL transakcji
Transakcje z użyciem aplikacji mobilnych będą raportować takie adresy URL:
mbappgewtimrzgyytanjyg4888888.com
Użyj dekodera base-32 do zdekodowania pogrubionej części ciągu znaków (gewtimrzgyytanjyg4888888
).
Możesz użyć dekodera online, ale musisz używać wielkich liter, a wartości 8
na końcu musisz zastąpić wartościami =
.
Dekodowanie tej wartości:
GEWTIMRZGYYTANJYG4======powoduje:
1-429610587Ciąg
429610587
to identyfikator aplikacji na iOS
iFunny.
Oto kolejny przykład. Zgłoszony adres URL to:
mbappgewtgmjug4ytmmrtgm888888.comDekodowanie tej wartości:
GEWTGMJUG4YTMMRTGM======wyniki daje:
1-314716233Wynik
314716233
to identyfikator aplikacji na iOS
TextNow.
Znajdowanie nazwy aplikacji mobilnej na podstawie adresu URL transakcji
Oto przykład uzyskania nazwy aplikacji. Zgłoszony adres URL wygląda tak:
mbappMFUXELTDN5WS42DZOBQWQLTJN4XHG3DJORUGK4Q888.comZdekodowanie tej wartości:
MFUXELTDN5WS42DZOBQWQLTJN4XHG3DJORUGK4Q===wyniki daje:
air.com.hypah.io.slitherWynik odpowiada aplikacji na Androida slither.io.
Pola Otwartego ustalania stawek
Pytania o stawkę wysyłane do licytujących na giełdach i w sieci, którzy uczestniczą w Otwartym ustalaniu stawek, są podobne do pytań z usługi Authorized Buyers, które uczestniczą w standardowym określaniu stawek w czasie rzeczywistym. Klienci korzystający z Otwartego ustalania stawek otrzymają niewielką liczbę dodatkowych pól, a kilka dotychczasowych pól może mieć alternatywne zastosowania. Obejmują one:
OpenRTB | Authorized Buyers; | Szczegóły |
---|---|---|
BidRequest.imp[].ext.dfp_ad_unit_code |
BidRequest.adslot[].dfp_ad_unit_code |
Zawiera kod sieci Ad Managera wydawcy, po którym następuje hierarchia jednostek reklamowych, rozdzielone ukośnikami. Przykładowy format: |
BidRequest.user.data[].segment[] |
BidRequest.adslot[].exchange_bidding.key_value[] |
Powtórzone pary klucz-wartość wysyłane od wydawcy do licytującego na giełdzie. Możesz ustalić, że wartości są parami klucz-wartość wysyłanymi przez wydawcę, gdy |
Deklarowanie dozwolonych dostawców
Dostawcy technologii, którzy świadczą usługi takie jak badania, remarketing i wyświetlanie reklam, mogą odgrywać rolę w interakcji między kupującymi a sprzedawcami. Dozwolone są tylko dostawcy, którzy zostali zweryfikowani przez Google pod kątem udziału w interakcjach z Authorized Buyers.
Aby zrozumieć zasady BidRequest
i utworzyć BidResponse
, musisz wiedzieć, że deklarowanie dostawców technologii jest możliwe na 2 sposoby:
- Niektórzy dostawcy nie muszą być deklarowane. Lista ich znajdziesz w Centrum pomocy Authorized Buyers.
- Inni dostawcy mogą uczestniczyć w programie tylko wtedy, gdy są zadeklarowani zarówno w
BidRequest
, jak i wBidResponse
:- W
BidRequest
poleallowed_vendor_type
określa dostawców, na których zezwala sprzedawca. Dostawcy wymienieni w poluallowed_vendor_type
wBidRequest
są wymienieni w pliku słownikaVendors.txt
. - W
BidResponse
polevendor_type
określa, z których z dozwolonych dostawców kupujący chce korzystać.
- W
Przykładowe pytanie o stawkę
Poniższe przykłady przedstawiają czytelne dla człowieka próbki żądań Protobuf i JSON.
Plik JSON OpenRTB
Protobuf OpenRTB
Aby przekonwertować pytanie o stawkę na postać binarną (tak jak w przypadku ładunku POST w rzeczywistym żądaniu), wykonaj te czynności (w języku C++). Pamiętaj, że nie dotyczy to formatu JSON OpenRTB.
string text_format_example = /* example from above */; BidRequest bid_request; if (TextFormat::ParseFromString(text_format_example, &bid_request)) { string post_payload; if (bid_request.SerializeToString(&post_payload)) { // post_payload is a binary serialization of the protocol buffer } }
Remarketing
Authorized Buyers przekazuje z aplikacji mobilnej identyfikator wyświetlania reklam mobilnych w pytaniach o stawkę. Identyfikatorem wyświetlania reklam mobilnych może być IDFA na iOS lub
identyfikator wyświetlania reklam w Androidzie. Wysyłany jest on za pomocą makra
%%EXTRA_TAG_DATA%%
w tagu JavaScript zarządzanym przez usługę Authorized Buyers.
Makro %%ADVERTISING_IDENTIFIER%%
umożliwia kupującym otrzymywanie identyfikatora IDFA na iOS lub identyfikatora wyświetlania reklam na urządzeniu z Androidem podczas renderowania wyświetleń. Zwraca zaszyfrowany bufor proto MobileAdvertisingId
taki jak
%%EXTRA_TAG_DATA%%
:
message MobileAdvertisingId { optional bytes advertising_id = 1; optional int32 user_id_type = 2; }
user_id_type
jest jedną z wartości zdefiniowanych w enum AdxMobileIdType
:
enum AdxMobileIdType { MOBILE_ID_UNKNOWN = 0, IDFA = 1, ANDROID_ID = 2, };
Listy użytkowników możesz tworzyć na podstawie identyfikatorów wyświetlania reklam mobilnych, korzystając z identyfikatorów wyświetlania reklam zebranych podczas renderowania wyświetleń. Listy użytkowników mogą być przechowywane na Twoim serwerze albo na naszym serwerze. Aby utworzyć listy użytkowników na serwerach Google, możesz skorzystać z naszej usługi przesyłania zbiorczego.
Gdy identyfikator wyświetlania reklam mobilnych pasuje do listy użytkowników, możesz go używać do remarketingu.
Opinie w czasie rzeczywistym
Opinie w czasie rzeczywistym są dostępne dla Authorized Buyers, a także giełd i sieci korzystających z Otwartego ustalania stawek.
Odpowiedzi na pytania o stawkę są obsługiwane w kolejnych pytaniach o stawkę zarówno w przypadku protokołów AdX, jak i OpenRTB. W przypadku OpenRTB jest on wysyłany w obrębie BidRequestExt
.
Oprócz domyślnych pól wysyłanych w odpowiedzi na pytanie o stawkę możesz też wysyłać dane niestandardowe w odpowiedzi na stawkę (w AdX Proto lub OpenRTB) za pomocą metody event_notification_token
zwracanej w BidResponse
. event_notification_token
to dowolne dane znane tylko licytującemu, które mogą pomóc w debugowaniu, np. nowy identyfikator kierowania lub identyfikator ustalania stawek reprezentujący nową taktykę albo metadane powiązane z kreacją, które są znane tylko licytującemu. Więcej informacji znajdziesz w artykule OpenRTB Protocol Buffer (Bufor protokołu OpenRTB) do RTB i AdX Proto dla AdX.
Gdy Authorized Buyers wysyła do licytującego pytanie o stawkę, licytujący odpowiada BidResponse
. Jeśli licytujący ma włączone przesyłanie opinii w czasie rzeczywistym, w kolejnym pytaniu o stawkę wysyła opinię o odpowiedzi w komunikacie BidResponseFeedback
, jak pokazano poniżej:
// 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; // 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 spend and invalid // traffic metrics in IVT transparency reporting in Query Tool. 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 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 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; // 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; // 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; } // 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; }
Pierwsze pole, które należy sprawdzić w tej wiadomości, to bid_response_feedback.creative_status_code
. Znaczenie kodu znajdziesz w pliku
creative-status-codes.txt. Pamiętaj, że jeśli wygrasz stawkę, możesz zrezygnować z opinii o cenach. Więcej informacji znajdziesz w artykule Jak zrezygnować.
Informacje zwrotne w czasie rzeczywistym zawierają identyfikator pytania o stawkę i jeden z tych elementów:
Wynik aukcji | Opinie w czasie rzeczywistym |
---|---|
Kupujący nie przesłał stawki. | Nic. |
Kupujący przesłał stawkę, która została odfiltrowana, zanim trafiła na aukcję. | Kod stanu kreacji (creative-status-codes.txt). |
Kupujący przesłał stawkę, ale przegrał aukcję. | Kod stanu kreacji 79 (przegrana w aukcji). |
Kupujący przesłał stawkę, która wygrała aukcję. | Cena rozliczeniowa i kod stanu kreacji: 1 .
W przypadku wyświetlenia w aplikacji i kodu stanu kreacji o wartości |
Przykład
Poniżej znajduje się przykład informacji zwrotnych przesyłanych w czasie rzeczywistym w obsługiwanych protokołach:
Plik JSON OpenRTB
Protobuf OpenRTB
Tworzenie modelu ustalania stawek na potrzeby aukcji pierwszej ceny
Po ustaleniu stawki w aukcji pierwszej ceny otrzymasz informacje zwrotne w czasie rzeczywistym, w tym pola minimum_bid_to_win
i sampled_mediation_cpm_ahead_of_auction_winner
, jeśli stawka nie została odfiltrowana z aukcji. Sygnały te można wykorzystać do ustalania, o ile wyższa lub niższa byłaby stawka, aby wygrać wyświetlenie.
minimum_bid_to_win
: minimalna stawka, jaką można było ustawić, aby wygrać aukcję z określaniem stawek w czasie rzeczywistym. Jeśli wygrasz aukcję, będzie to najniższa stawka, jaką można było zaoferować, a jednocześnie nadal wygrywać. Jeśli przegrasz aukcję, będzie to zwycięska stawka.sampled_mediation_cpm_ahead_of_auction_winner
: jeśli w łańcuchu zapośredniczenia są też inne sieci, wartość w tym polu to cena reprezentująca przykładową stawkę z jednej z odpowiednich sieci zapośredniczenia, która była wyższa niż zwycięzca aukcji i ważona według oczekiwanego współczynnika wypełnienia. Jeśli żadna z sieci w łańcuchu zapośredniczenia nie powinna wypełniać żadnej sieci lub jeśli wydawca nie korzysta z zapośredniczenia SDK, ma wartość 0.
Jak to działa
Aby opisać obliczenia użyte do określenia możliwych wartości dla funkcji minimum_bid_to_win
i sampled_mediation_cpm_ahead_of_auction_winner
, musimy najpierw zdefiniować:
- Poniżej podajemy wartości CPM w łańcuchu zapośredniczenia w kolejności malejącej:
\[C_1, C_2, …, C_n\]
- Poniżej przedstawiono odpowiadające współczynniki wypełnienia dla CPM w łańcuchu zapośredniczenia:
\[f_1, f_2, …, f_n\]
- Ta funkcja służy do określania oczekiwanego CPM i prawdopodobieństwa z elementu łańcucha zapośredniczenia \(i\)na podstawie podanego współczynnika wypełnienia:
\(X_i = \{C_i\) z prawdopodobieństwem \(f_i\); \(0\) z prawdopodobieństwem \(1 - f_i\}\)
- Ostatni zwycięski łańcuch zapośredniczenia to:
\[\{C_1, C_2, …, C_K, W\}\]gdzie \(W\) jest zwycięska stawka oraz \(C_K > W >= C_{K+1}\)
- Cena minimalna jest oznaczona jako \(F\).
- Stawka za drugie miejsce jest oznaczona jako \(R\).
Obliczenia dotyczące zwycięzcy aukcji
Pole | Obliczenie |
---|---|
minimum_bid_to_win |
\(max\{F, R, X_{K+1}, …, X_n\}\) |
sampled_mediation_cpm_ahead_ |
\(\{C_i\) z prawdopodobieństwem \(\prod_{j=1}^{i-1}(1-f_j) \cdot f_i \div \prod_{j=1}^{K}(1-f_j)\}\)
Dotyczy \(1 <= i <= K\). |
Obliczenia dotyczące przegranych aukcji
Pole | Obliczenie |
---|---|
minimum_bid_to_win |
\(max\{F, W\}\) |
sampled_mediation_cpm_ahead_ |
\(max\{X_1, …, X_K\}\) |
Przykład z prostym łańcuchem zapośredniczenia
Załóżmy, że wydawca używa zarówno określania stawek w czasie rzeczywistym, jak i łańcucha zapośredniczenia SDK w taki sposób:
Łańcuch zapośredniczenia SDK | Oczekiwany CPM | Współczynnik wypełnienia |
---|---|---|
Sieć 1 | \(C_1 = $3.00\) | \(f_1 = 5\%\) |
Sieć 2 | \(C_2 = $2.00\) | \(f_2 = 45\%\) |
Sieć 3 | \(C_3 = $0.50\) | \(f_3 = 80\%\) |
Sieć 4 | \(C_4 = $0.10\) | \(f_4 = 85\%\) |
Zakładamy, że po przeprowadzeniu aukcji RTB:
Aukcja RTB | CPM |
---|---|
Zwycięzca aukcji (Z) | 4 PLN |
Z drugiej ręki (R) | 0,05 USD |
Cena minimalna / cena minimalna (F) | 0 zł |
Stawka, która wygrała aukcję
Poniżej znajdziesz przykład obliczania prawdopodobieństwa w przypadku stawki, która wygrała
minimum_bid_to_win
i sampled_mediation_cpm_ahead_of_auction_winner
.
minimum_bid_to_win |
Probability, |
---|---|
\(max(F, R, C_3) = $0.50\) | \(f_3 = 80\%\) |
\(max(F, R, C_4) = $0.10\) | \((1-f_3) \cdot f_4 = 17\%\) |
\(max(F, R, 0) = $0.05\) | \((1-f_3) \cdot (1-f_4) = 3\%\) |
sampled_mediation_cpm_ |
Probability, |
---|---|
\(C_1 = $3.00\) | \(f_1 \div (1-(1-f_1) \cdot (1-f_2)) =~ 10.5\%\) |
\(C_2 = $2.00\) | \(((1-f_1) \cdot f_2) \div (1-(1-f_1) \cdot (1-f_2)) =~ 89.5\%\) |
Stawki, które przegrały aukcję
Poniżej znajduje się przykład obliczania prawdopodobieństwa w przypadku przegranych stawek
minimum_bid_to_win
i sampled_mediation_cpm_ahead_of_auction_winner
.
minimum_bid_to_win |
Probability, |
---|---|
\(max(F, W) = $1.00\) | \(100\%\) |
sampled_mediation_cpm_ |
Probability, |
---|---|
\(C_1 = $3.00\) | \(f_1 = 5\%\) |
\(C_2 = $2.00\) | \((1-f_1) \cdot f_2 =~ 42.8\%\) |
\(0\) | \((1-f_1) \cdot (1-f_2) =~ 52.2\%\) |
Rozdzielanie stawek
Rozdzielanie stawek opisuje przetwarzanie pojedynczego złożonego elementu BidRequest
na wiele pytań o stawkę, które są wysyłane do Twojej aplikacji. Ponieważ zachowują one identyczne identyfikatory (BidRequest.google_query_id
w protokole RTB Authorized Buyers lub BidRequestExt.google_query_id
w protokole OpenRTB), możesz ustalić, które pytania o stawkę są skorelowane po scaleniu.
Formaty reklam
Niektóre możliwości wyświetlania reklam mogą obejmować wiele formatów. W przypadku rozdzielania stawek każdy format jest wysyłany w osobnym pytaniu o stawkę, a takie atrybuty jak odpowiednie identyfikatory płatności mają związek z formatem określonym w pytaniu.
Pytania o stawkę zawierające te formaty zostaną scalone w odrębne pytania o stawkę:
- Baner
- Wideo
- Audio
- Natywna
Przykład spłaszczenia formatu reklamy
Poniżej znajduje się przykład przedstawiający uproszczone pytanie o stawkę w formacie JSON OpenRTB bez rozdzielania formatu reklamy w porównaniu z odpowiednim zestawem płaskich żądań:
Wstępnie spłaszcz
Po spłaszczeniu
Okazje
Możliwość wyświetlania reklam w przypadku danego licytującego może się odnosić nie tylko do aukcji otwartej, ale też w różnych typach umów. W przypadku umów o rozdzielaniu stawek po jednym pytaniu o stawkę w przypadku aukcji otwartej zostanie wysłane 1 pytanie o stawkę dla każdego typu umowy o stałej cenie. W praktyce ograniczenia dotyczące reklam mogą się różnić w zależności od aukcji i umów o stałej cenie. Na przykład w przypadku możliwości związanych z reklamami wideo dostępnych zarówno dla aukcji otwartej, jak i umowy o stałej cenie system licytujący będzie otrzymywać osobne pytania o stawkę w przypadku każdego z nich, gdy takie ograniczenia jak maksymalny czas trwania reklamy i dopuszczanie reklam możliwych do pominięcia mogą się różnić. W efekcie zastosowanie tej opcji do możliwości reklamowej ułatwia rozróżnianie ograniczeń dotyczących reklam w aukcjach otwartych i umowach o stałej cenie.
Maksymalny czas trwania reklamy wideo możliwej do pominięcia
Protokół Google i implementacja OpenRTB obsługują te pola dotyczące czasu trwania filmu i możliwości pominięcia:
Czas działania | Czas trwania reklamy możliwej do pominięcia | Możliwość pominięcia | |
---|---|---|---|
Protokół Google | max_ad_duration |
skippable_max_ad_duration |
video_ad_skippable |
OpenRTB | maxduration |
nie dotyczy | skip |
Oznacza to, że chociaż protokół Google może mieć szczegółowy czas trwania reklam możliwych i niemożliwych do pominięcia, implementacja OpenRTB ma tylko jedną wartość maksymalnego czasu trwania.
Przed rozdzielaniem stawek wartość maxduration
OpenRTB była ustawiona na niższą wartość z pól max_ad_duration
i skippable_max_ad_duration
protokołu Google. Zamiast tego wysyłanie 2 osobnych pytań o stawkę w przypadku różnic między tymi wartościami: jedno oznacza atrybut maxduration
w przypadku reklam możliwych do pominięcia, a drugie niemożliwe do pominięcia.
W przykładach poniżej widać, jak żądanie protokołu Google przekłada się na OpenRTB przed rozdzielaniem stawek i po nim. Odpowiednik żądania protokołu Google ma wartość max_ad_duration
równą 15
, a skippable_max_ad_duration
o wartości 60
.
Przykład | max_ad_duration |
skip (prawda LUB fałsz) |
---|---|---|
Pierwotne żądanie bez rozdzielania | 15 |
true |
Żądanie spłaszczone 1: niemożliwe do pominięcia | 15 |
false |
Żądanie spłaszczone nr 2: reklama możliwa do pominięcia | 60 |
true |
Rozdzielanie pytań o stawkę za czas trwania reklam wideo możliwych do pominięcia odbywa się tylko wtedy, gdy są spełnione te warunki:
- Żądanie zezwala na wideo.
- Dozwolone są zarówno filmy z możliwością pominięcia, jak i bez pominięcia, a 2 maksymalne czasy trwania różnią się wartością.
- To żądanie kwalifikuje się do aukcji prywatnej lub aukcji otwartej.
- Konto licytującego ma aktywne punkty końcowe OpenRTB.
Możesz zrezygnować z tego typu rozdzielania, kontaktując się z technicznym menedżerem konta.
Bloki reklamowe wideo
Pytania o stawkę w bloku reklamowym wideo z wieloma możliwościami reklamowymi są rozdzielane tak, że każde pytanie o stawkę dotyczy pojedynczej możliwości reklamy z tego bloku reklamowego. Dzięki temu możesz ustalać stawki za wiele możliwości reklamowych w danym bloku reklamowym.
Open Measurement
Open Measurement pozwala określić dostawców zewnętrznych, którzy świadczą niezależne usługi pomiarowe i weryfikacyjne na potrzeby reklam wyświetlanych w środowiskach aplikacji mobilnych.Aby dowiedzieć się, czy wydawca obsługuje Open Measurement w pytaniu o stawkę, sprawdź, czy możliwość wyświetlania reklamy wyklucza atrybut OmsdkType:
OMSDK 1.0
, który znajduje się w atrybutach kreacji możliwych do wykluczenia przez wydawcę. W przypadku protokołu Authorized Buyers znajdziesz go w sekcji BidRequest.adslot[].excluded_attribute
. W przypadku protokołu OpenRTB znajduje się on w atrybucie battr
Baner lub Wideo, w zależności od formatu.
Więcej informacji o interpretowaniu pytań o stawkę zawierających sygnały Open Measurement znajdziesz w artykule Pakiet SDK Open Measurement w Centrum pomocy.
Przykładowe pytania o stawkę
W sekcjach poniżej znajdziesz przykładowe pytania o stawkę w przypadku różnych typów reklam.