सेलर के तौर पर B&A से इंटिग्रेट करना

बिडिंग और नीलामी (बीएंडए) सेवाएं, विज्ञापन खरीदारों और विज्ञापन देने वाले लोगों या कंपनियों के लिए सेवाओं का एक सेट है. यह सुरक्षित ऑडियंस (पीए) की नीलामी को आसान बनाने के लिए, ट्रस्टेड एक्ज़ीक्यूशन एनवायरमेंट (टीईई) में काम करता है. डेवलपर के लिए बनी इस गाइड में बताया गया है कि कोई सेलर, ब्रैंड और ऐप्लिकेशन के प्रमोशन के लिए Chrome PA ऑक्शन के साथ कैसे इंटिग्रेट कर सकता है.

कदम-दर-कदम निर्देश

सेलर इंटिग्रेशन फ़्लो, जिसमें JavaScript कोड को B&A ऑक्शन पेलोड मिलता है. यह पेलोड SAS को भेजा जाता है. इसके बाद, SAS अनुरोध को सेलर फ़्रंट-एंड (एसएफ़ई) को फ़ॉरवर्ड करता है. SFE, ऐसा नतीजा दिखाता है जिसे SAS को ब्राउज़र पर भेजना चाहिए. साथ ही, सेलर का JavaScript कोड, runAdAuction को कॉल करता है

इस प्रोसेस के बारे में यहां बताया गया है:

  1. ब्राउज़र से एन्क्रिप्ट (सुरक्षित) किया गया पेलोड पाने के लिए, getInterestGroupAdAuctionData() को कॉल करें
  2. fetch('https://your-ad-server.example') को कॉल करें और एन्क्रिप्ट (सुरक्षित) किए गए पेलोड के साथ, यूनिफ़ाइड ऑक्शन का अनुरोध अपने एसएएस को भेजें
  3. B&A नीलामी चलाने के लिए, अपने SAS से SFE के SelectAd() ऑपरेशन को कॉल करें
  4. पेज पर B&A नीलामी का नतीजा और रिस्पॉन्स का हैश वापस भेजता है
  5. एक सेलर, मिक्स्ड-मोड या एक से ज़्यादा सेलर वाली पीए नीलामी चलाने के लिए, ब्राउज़र में runAdAuction() को कॉल करें. साथ ही, सर्वर-साइड बीऐंडए नीलामी के नतीजे को कॉल में पास करें

विज्ञापन की नीलामी का एन्क्रिप्ट किया गया डेटा पाना

वॉकथ्रू का वही डायग्राम, जिसमें पहले चरण को हाइलाइट किया गया है. इस चरण में, सेलर का JavaScript कोड, getInterestGroupAdAuctionData को कॉल करता है

सर्वर-साइड B&A ऑक्शन को चलाने के लिए ज़रूरी डेटा पाने के लिए, पब्लिशर पेज पर मौजूद सेलर का JavaScript कोड, navigator.getInterestGroupAdAuctionData() को कॉल करता है.

const adAuctionData = await navigator.getInterestGroupAdAuctionData({
  seller: 'https://ssp.example', // Required
  requestSize: 51200,
  coordinatorOrigin: 'https://publickeyservice.pa.gcp.privacysandboxservices.com/',
  perBuyerConfig: {
    'https://dsp-x.example': { targetSize: 8192 },
    'https://dsp-y.example': { targetSize: 8192 }
  }
});

const { requestId, request } = adAuctionData;
फ़ील्ड ब्यौरा
seller ज़रूरी है. नीलामी करने वाले सेलर का देश. यह वैल्यू, बाद में runAdAuction() कॉल में मौजूद seller वैल्यू से मेल खानी चाहिए.
requestSize Optional. इससे खरीदार के सभी डेटा के पेलोड का ज़्यादा से ज़्यादा साइज़ सेट किया जाता है. ज़्यादा जानने के लिए, जानकारी देने वाले लेख में अनुरोध का साइज़ सेक्शन देखें.
perBuyerConfig Optional. यह हर खरीदार के लिए कॉन्फ़िगरेशन सेट करता है. साथ ही, यह भी कंट्रोल करता है कि कौनसे खरीदार, B&A नीलामी में हिस्सा लेंगे.

अगर खरीदार के ओरिजन perBuyerConfig में शामिल हैं, तो खरीदार के दिलचस्पी वाले ग्रुप का सिर्फ़ वही डेटा पेलोड में शामिल किया जाता है. अगर perBuyerConfig में कोई खरीदार शामिल नहीं है, तो उपयोगकर्ता के सभी दिलचस्पी वाले ग्रुप को पेलोड में शामिल किया जाता है.
targetSize अगर requestSize सेट है, तो यह ज़रूरी नहीं है. अगर खरीदार के देश की जानकारी perBuyerConfig में सेट है, लेकिन requestSize सेट नहीं है, तो ज़रूरी है.

इससे खरीदार के डेटा के पेलोड का ज़्यादा से ज़्यादा साइज़ सेट किया जाता है. ज़्यादा जानने के लिए, जानकारी देने वाले लेख में अनुरोध का साइज़ सेक्शन देखें.
coordinatorOrigin ज़रूरी नहीं, लेकिन बाद में इसकी ज़रूरत पड़ेगी. अगर इसे सेट नहीं किया जाता है, तो डिफ़ॉल्ट रूप से इसकी वैल्यू https://publickeyservice.pa.gcp.privacysandboxservices.com होती है.

यह कुकी, पेलोड को एन्क्रिप्ट (सुरक्षित) करने के लिए कुंजी को फ़ेच करने के लिए कोऑर्डिनेटर सेट करती है. ज़्यादा जानने के लिए, जानकारी देने वाले लेख का कोऑर्डिनेटर सेक्शन देखें.

कॉल किए जाने पर ब्राउज़र, perBuyerConfig में शामिल खरीदारों के इंटरेस्ट ग्रुप को पढ़ता है और खरीदार के डेटा को एन्क्रिप्ट (सुरक्षित) करता है. इस खरीदार के डेटा में, अलग-अलग साइटों की जानकारी शामिल होती है. इसका इस्तेमाल बिडिंग के लिए किया जाता है. इसे टीईई के बाहर डिक्रिप्ट नहीं किया जा सकता. पे लोड ऑप्टिमाइज़ेशन के लिए, पे लोड में सिर्फ़ दिलचस्पी वाले ग्रुप का नाम, भरोसेमंद बिडिंग सिग्नल की, और ब्राउज़र सिग्नल शामिल किए जाते हैं.

getInterestGroupAdAuctionData() कॉल से मिले विज्ञापन नीलामी के डेटा ऑब्जेक्ट में, requestId स्ट्रिंग और एन्क्रिप्ट किया गया request बाइट ऐरे उपलब्ध होता है.

Chrome DevTools का स्क्रीनशॉट. इसमें दिखाया गया है कि विज्ञापन की नीलामी के डेटा में अनुरोध और अनुरोध आईडी उपलब्ध है.

requestId स्ट्रिंग का इस्तेमाल बाद में तब किया जाता है, जब ब्राउज़र में नीलामी पूरी करने के लिए runAdAuction() को कॉल किया जाता है. एन्क्रिप्ट (सुरक्षित) किया गया request पेलोड, यूनिफ़ाइड ऑक्शन के अनुरोध के तौर पर, सेलर विज्ञापन सेवा को भेजा जाता है.

इस कॉल का उदाहरण देखने के लिए, स्थानीय टेस्टिंग ऐप्लिकेशन का सेलर JavaScript कोड देखें.

SAS को यूनिफ़ाइड ऑक्शन का अनुरोध भेजना

वॉकथ्रू का वही डायग्राम, जिसमें दूसरे चरण को हाइलाइट किया गया है. इस चरण में, सेलर का JavaScript कोड, SAS को यूनीफ़ाइड ऑक्शन का अनुरोध भेजता है

यूनीफ़ाइड ऑक्शन अनुरोध, ऐसा अनुरोध होता है जिसमें कॉन्टेक्स्ट के हिसाब से नीलामी के लिए, प्लेनटेक्स्ट वाला पेलोड और पीए बीऐंडए ऑक्शन पेलोड शामिल होता है. PA B&A ऑक्शन पेलोड, एन्क्रिप्ट (सुरक्षित) किया गया request डेटा होता है. इसे ब्राउज़र ने getInterestGroupAdAuctionData() कॉल में जनरेट किया था. यह अनुरोध SAS को भेजा जाता है. यहां कॉन्टेक्स्ट के हिसाब से नीलामी और PA B&A नीलामी को व्यवस्थित किया जाता है.

fetch('https://ssp.example/ad-auction', {
  method: 'POST',
  adAuctionHeaders: true,
  body: JSON.stringify({
    contextualAuctionPayload: { somePayload },
    protectedAudienceAuctionPayload: encodeBinaryData(request)
  }),
});

SAS को अनुरोध भेजने के लिए, पेज से fetch() कॉल किया जाता है:

  • कॉल में adAuctionHeaders: true विकल्प शामिल होना चाहिए. इससे ब्राउज़र को यह सिग्नल मिलता है कि इस कॉल के रिस्पॉन्स की पुष्टि बाद में की जाएगी. ऐसा तब किया जाएगा, जब ब्राउज़र में नीलामी पूरी करने के लिए runAdAuction() को कॉल किया जाएगा.
  • फ़ेच अनुरोध का ऑरिजिन, getInterestGroupAdAuctionData() और runAdAuction() कॉल को दिए गए seller ऑरिजिन से मेल खाना चाहिए.

कॉल के मुख्य हिस्से में यह जानकारी शामिल होती है:

  1. यह टेक्स्ट फ़ॉर्मैट में संदर्भ के हिसाब से नीलामी का पेलोड होता है. इसका इस्तेमाल, SAS को संदर्भ के हिसाब से नीलामी चलाने के लिए करना होता है.
  2. एन्क्रिप्ट किया गया Protected Audience API से जुड़ी नीलामी का पेलोड. इसे SAS, SFE को भेजता है, ताकि सर्वर-साइड B&A नीलामी की जा सके.

इस कॉल का उदाहरण देखने के लिए, स्थानीय टेस्टिंग ऐप्लिकेशन का सेलर JavaScript कोड देखें.

Base64 एन्कोडिंग और डिकोडिंग

getInterestGroupAdAuctionData() कॉल से मिला एन्क्रिप्ट (सुरक्षित) किया गया request पेलोड, Uint8Array का एक इंस्टेंस है. यह एक ऐसा डेटा टाइप है जिसे JSON हैंडल नहीं कर सकता. बाइट ऐरे को JSON फ़ॉर्मैट में भेजने के लिए, बाइनरी डेटा पर base64 एन्कोडिंग लागू करके, उसे स्ट्रिंग में बदला जा सकता है.

JavaScript ब्राउज़र एपीआई, window पर atob() और btoa() फ़ंक्शन उपलब्ध कराता है. ये फ़ंक्शन, बाइनरी डेटा और base64 में एन्कोड किए गए ASCII स्ट्रिंग के बीच कन्वर्ज़न करते हैं. (atob का मतलब ASCII से बाइनरी में बदलना है और btoa का मतलब बाइनरी से ASCII में बदलना है).

बाइनरी डेटा को base64 कोड में बदली गई स्ट्रिंग में बदलने के लिए, btoa() को कॉल करें. यह इस तरह दिखता है:

function encodeBinaryData(data) {
  return btoa(String.fromCharCode.apply(null, data));
}

इस fetch कॉल से मिला, एन्क्रिप्ट (सुरक्षित) किया गया B&A ऑक्शन का नतीजा भी base64 एन्कोडिंग में होता है. इसलिए, आपको इसे वापस बाइनरी डेटा में डिकोड करना होगा. base64 में एन्कोड की गई ASCII स्ट्रिंग को बाइनरी डेटा में डिकोड करने के लिए, atob() को कॉल करें:

function decodeBase64String(base64string) {
  return new Uint8Array(
    atob(base64string)
      .split('')
      .map((char) => char.charCodeAt(0))
  );
}

हालांकि, base64 कोड में बदली गई स्ट्रिंग, आम तौर पर ओरिजनल डेटा से करीब 33% बड़ी होती है. अगर आपको और भी कम समय में डेटा भेजना है, तो बाइनरी डेटा भेजने के लिए JSON के अलावा किसी अन्य फ़ॉर्मैट का इस्तेमाल करें.

B&A नीलामी चलाने के लिए, SFE के SelectAd को कॉल करें

तीसरे चरण को हाइलाइट करने वाला वही वॉकट्रू डायग्राम. इस चरण में, SAS, SFE को SelectAd अनुरोध भेजता है और SFE, B&A नीलामी करता है

जब पेज से Seller Ad Service को यूनीफ़ाइड ऑक्शन का अनुरोध मिलता है, तो सबसे पहले कॉन्टेक्स्ट के हिसाब से ऑक्शन होता है. इससे कॉन्टेक्स्ट के हिसाब से ऑक्शन जीतने वाले व्यक्ति का पता चलता है. साथ ही, खरीदार के ऐसे सिग्नल इकट्ठा किए जाते हैं जिन्हें PA B&A ऑक्शन में पास किया जा सकता है. इसके बाद, अनुरोध पेलोड के साथ SAS से SFE के SelectAd ऑपरेशन को कॉल करके, B&A नीलामी शुरू की जाती है. ध्यान दें कि पेज के अनुरोध से मिला कुछ मेटाडेटा, एसएएस को दूसरे चरण में भेजा जाता है. इसके बाद, इसे एसएफ़ई को फ़ॉरवर्ड किया जाता है.

SelectAdRequest पेलोड बनाना

SelectAd कॉल के अनुरोध पेलोड को इस तरह बनाया जा सकता है:

const selectAdRequest = {
  auction_config: {
    seller: 'https://ssp.example',
    auction_signals: '{"testKey":"someValue"}',
    seller_signals: '{"testKey":"someValue"}',
    buyer_list: [
      'https://dsp-x.example',
      'https://dsp-y.example',
    ],
    per_buyer_config: {
      'https://dsp-x.example': { buyer_signals: '{"testKey": "someValue"}' },
      'https://dsp-y.example': { buyer_signals: '{"testKey": "someValue"}' },
    },
  },
  client_type: 'CLIENT_TYPE_BROWSER',
  protected_auction_ciphertext: decodeBase64string(request)
};

ध्यान दें कि अगर ब्राउज़र से मिला एन्क्रिप्ट (सुरक्षित) किया गया विज्ञापन नीलामी का डेटा, base64-encoded था, तो gRPC का इस्तेमाल करके SFE को अनुरोध भेजने पर, उसे बाइनरी डेटा में वापस डिकोड करना होगा. अगर अनुरोध HTTP का इस्तेमाल करके भेजा जाता है, तो एन्क्रिप्ट (सुरक्षित) किया गया विज्ञापन नीलामी का डेटा, base64-encoded फ़ॉर्म में रह सकता है.

SelectAd अनुरोध में तय किए गए अन्य फ़ील्ड देखने के लिए, SelectAdRequest की प्रोटो परिभाषा देखें.

मिक्स-मोड और कॉम्पोनेंट ऑक्शन के लिए, सेलर फ़ील्ड का टॉप-लेवल सेट करना

अगर सेलर, मिक्स्ड-मोड वाली नीलामी कर रहा है या एक से ज़्यादा सेलर वाली नीलामी में कॉम्पोनेंट सेलर के तौर पर हिस्सा ले रहा है, तो अनुरोध में top_level_seller फ़ील्ड को तय करना होगा.

अगर आप मिक्स्ड-मोड सेलर हैं, तो top_level_seller वैल्यू आपके प्रॉडक्ट का मूल देश है:

const selectAdRequest = {
  auction_config: {
    seller: 'https://ssp-mix.example',
    top_level_seller: 'https://ssp-mix.example',
  }
}

अगर आप कॉम्पोनेंट बेचने वाले सेलर हैं, तो top_level_seller वैल्यू, मल्टी-सेलर ऑक्शन के टॉप-लेवल सेलर की वैल्यू होती है:

const selectAdRequest = {
  auction_config: {
    seller: 'https://ssp-mix.example',
    top_level_seller: 'https://ssp-top.example',
  }
}

एसएफ़ई के SelectAd पर कॉल करें

SAS से SFE को कॉल करने के लिए, gRPC या एचटीटीपी का इस्तेमाल किया जा सकता है.

gRPC कॉल

gRPC क्लाइंट के साथ Node में Express का इस्तेमाल करके, SFE को किया गया gRPC अनुरोध इस तरह दिखता है:

import grpc from '@grpc/grpc-js';

// Load proto definition
const packageDefinition = protoLoader.loadSync(protoPath, { keepCase: true, enums: String });

const {
  privacy_sandbox: {
    bidding_auction_servers: { SellerFrontEnd }
  }
} = grpc.loadPackageDefinition(packageDefinition);

// Instantiate the gRPC client
const sfeGrpcClient = new SellerFrontEnd('192.168.84.104:50067', grpc.credentials.createInsecure());

// Send SelectAd request
sfeGrpcClient.selectAd(selectAdRequest,(error, response) => {
  // Handle SFE response
});

SFE क्लाइंट के लिए प्रोटो डेफ़िनिशन, लोकल टेस्टिंग ऐप्लिकेशन रिपॉज़िटरी में देखी जा सकती है.

Envoy प्रॉक्सी को एचटीटीपी कॉल

SFE को भेजा गया एचटीटीपी पोस्ट अनुरोध, /v1/selectAd पाथ पर भेजा जाता है. यह कुछ इस तरह दिखता है:

fetch('https://ssp-ba.example/sfe/v1/selectAd', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(selectAdRequest),
});

मेटाडेटा फ़ॉरवर्ड करना

पेज के SAS कॉल से मिले इस मेटाडेटा को, SAS के SelectAd कॉल से SFE में जोड़ा जाना चाहिए:

SFE को मेटाडेटा भेजते समय, उन्हें यहां दिए गए नॉन-स्टैंडर्ड हेडर का इस्तेमाल करना होगा. ऐसा इसलिए, क्योंकि gRPC, User-Agent हेडर में बदलाव कर सकता है:

  • X-Accept-Language
  • X-User-Agent
  • X-BnA-Client-IP

यहां Node में Express का इस्तेमाल करके, gRPC क्लाइंट की मदद से मेटाडेटा को फ़ॉरवर्ड करने का एक उदाहरण दिया गया है:

sellerAdService.post('/ad-auction', (req, res) => {
  // …
  const metadata = new grpc.Metadata();
  metadata.add('X-Accept-Language', req.header('Accept-Language'));
  metadata.add('X-User-Agent', req.header('User-Agent'));
  metadata.add('X-BnA-Client-IP', req.ip);

  const sfeGrpcClient = createSfeGrpcClient();
  sfeGrpcClient.selectAd(selectAdRequest, metadata, callbackFn);
})

यहां एचटीटीपी कॉल का इस्तेमाल करके, मेटाडेटा को फ़ॉरवर्ड करने का तरीका बताया गया है:

sellerAdService.post('/ad-auction', (req, res) => {
  // …
  fetch('https://ssp-ba.example/sfe/v1/selectAd', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Accept-Language': req.header('Accept-Language'),
      'X-User-Agent': req.header('User-Agent'),
      'X-BnA-Client-IP': req.ip
    },
    body: JSON.stringify(selectAdRequest)
  });
})

सर्वर के ज़रिए मैनेज की जाने वाली, एक से ज़्यादा सेलर वाली नीलामी

अगर आप टॉप-लेवल सेलर हैं और सर्वर-ऑर्केस्ट्रेटेड मल्टी-सेलर ऑक्शन चला रहे हैं, तो SelectAd कॉल किए जाने से पहले, SFE को GetComponentAuctionCiphertexts कॉल किया जाता है. जवाब में, फिर से एन्क्रिप्ट (सुरक्षित) किए गए कॉम्पोनेंट ऑक्शन पेलोड शामिल होते हैं. ये पेलोड, कॉम्पोनेंट बेचने वाले व्यक्ति या कंपनी की विज्ञापन सेवाओं को भेजे जाते हैं. नीलामी के नतीजों के तौर पर मिले कॉम्पोनेंट B&A विज्ञापन, टॉप-लेवल सेलर के SFE के SelectAd कॉल को भेजे जाते हैं.

ज़्यादा जानने के लिए, GitHub पर एक से ज़्यादा सेलर के बारे में जानकारी देने वाला लेख पढ़ें.

पेज पर B&A ऑक्शन का नतीजा वापस दिखाएं

वॉकथ्रू डायग्राम में चौथा चरण हाइलाइट किया गया है. इस चरण में, SAS, SelectAd के ऑक्शन के नतीजे को ब्राउज़र पर वापस भेजता है

B&A नीलामी पूरी होने के बाद, एन्क्रिप्ट (सुरक्षित) किया गया नीलामी का नतीजा SAS को भेजा जाता है. इसके बाद, SAS, दूसरे चरण में पेज से मिले यूनीफ़ाइड नीलामी के अनुरोध का जवाब, एन्क्रिप्ट (सुरक्षित) किए गए नीलामी के नतीजे के साथ देता है. पेज के लिए SAS के रिस्पॉन्स में, एन्क्रिप्ट (सुरक्षित) किए गए नीलामी के नतीजे का base64url-एन्कोड किया गया SHA-256 हैश, Ad-Auction-Result रिस्पॉन्स हेडर में सेट किया जाता है. इस हैश का इस्तेमाल ब्राउज़र, पेलोड की पुष्टि करने के लिए करता है. ऐसा तब किया जाता है, जब क्लाइंट में नीलामी पूरी हो जाती है.

Node में, base64 एन्कोडिंग का इस्तेमाल करके SHA-256 हैश बनाने का तरीका यहां दिया गया है:

import { createHash } from 'crypto';

createHash('sha256')
  .update(binaryData, 'base64')
  .digest('base64url');

जवाब के हेडर में हैश अटैच करने और पेज पर नीलामी का नतीजा दिखाने का तरीका यहां दिया गया है:

sellerAdService.post('/ad-auction', (req, res) => {
  // …
  sfeGrpcClient.selectAd(selectAdRequest, metadata, (error, response) => {
    const { auction_result_ciphertext } = response;

    const ciphertextShaHash = createHash('sha256')
      .update(auction_result_ciphertext, 'base64')
      .digest('base64url');

    res.set('Ad-Auction-Result', ciphertextShaHash);

    res.json({
      protectedAudienceAuctionResult: encodeBinaryData(auction_result_ciphertext),
      contextualAuctionResult: getContextualAuctionResult()
    });
  });
})

यह दूसरे चरण में पेज से किए गए यूनीफ़ाइड ऑक्शन के अनुरोध का जवाब है. इसलिए, कॉन्टेक्स्चुअल ऑक्शन के नतीजे को भी जवाब में शामिल किया गया है.

हेडर को दोहराकर या हैश को अलग करके, Ad-Auction-Result में कई हैश शामिल किए जा सकते हैं. यहाँ दिए गए दो रिस्पॉन्स हेडर एक जैसे हैं:

Ad-Auction-Result: ungWv48Bz-pBQUDeXa4iI7ADYaOWF3qctBD_YfIAFa0=,9UTB-u-WshX66Xqz5DNCpEK9z-x5oCS5SXvgyeoRB1k=

Ad-Auction-Result: ungWv48Bz-pBQUDeXa4iI7ADYaOWF3qctBD_YfIAFa0=
Ad-Auction-Result: 9UTB-u-WshX66Xqz5DNCpEK9z-x5oCS5SXvgyeoRB1k=

इस कॉल का उदाहरण देखने के लिए, लोकल टेस्टिंग ऐप्लिकेशन का सेलर सर्वर कोड देखें.

नीलामी पूरी करने के लिए runAdAuction() को कॉल करें

वॉकथ्रू का वही डायग्राम, जिसमें पांचवें चरण को हाइलाइट किया गया है. इस चरण में, क्लाइंट-साइड JavaScript कोड, नीलामी को पूरा करता है और सर्वर के रिस्पॉन्स को दिखाता है.

SAS से मिले यूनिफ़ाइड ऑक्शन के जवाब में, एन्क्रिप्ट (सुरक्षित) किया गया B&A ऑक्शन का नतीजा शामिल होता है. इस पेलोड को runAdAuction() कॉल में पास किया जाता है, ताकि ब्राउज़र में नीलामी पूरी की जा सके. पहले चरण में, getInterestGroupAdAuctionData() कॉल से मिली requestId वैल्यू को भी नीलामी में पास किया जाता है.

// Get the encrypted ad auction data (Step #1)
const { requestId, request } = navigator.getInterestGroupAdAuctionData(adAuctionDataConfig)

// Send unified auction request (Step #2)
const response = await fetch('https://ssp-ba.example/ad-auction', {
  method: 'POST',
  body: JSON.stringify({
    adAuctionRequest: encodeBinaryData(request),
  }),
});

const { protectedAudienceAuctionResult } = await response.json();

// Finish the auction in the browser
await navigator.runAdAuction({
  // pass in "requestId" and "protectedAudienceAuctionResult"
  // the config structure will differ based on the auction configuration
});

runAdAuction() कॉल में पास किया गया ऑक्शन कॉन्फ़िगरेशन, सेलर के चुने गए ऑक्शन कॉन्फ़िगरेशन के आधार पर अलग-अलग होता है.

एक सेलर वाली नीलामी

एक सेलर के B&A कैंपेन की नीलामी चलाने के लिए, runAdAuction() कॉल का नीलामी कॉन्फ़िगरेशन इस तरह से बनाया जाता है:

await navigator.runAdAuction({
  seller: 'https://ssp-ba.example',
  requestId,
  serverResponse: protectedAudienceAuctionResult,
});

requestId फ़ील्ड, getInterestGroupAdAuctionData() कॉल से मिले requestId को स्वीकार करता है. serverResponse फ़ील्ड, तीसरे चरण में हुई B&A नीलामी के बाइट कलेक्शन को स्वीकार करता है.

इस कॉल का उदाहरण देखने के लिए, स्थानीय टेस्टिंग ऐप्लिकेशन का सेलर JavaScript कोड देखें.

मिक्स-मोड नीलामी

मिक्स-मोड वाली B&A नीलामी चलाने के लिए, runAdAuction() कॉल का ऑक्शन कॉन्फ़िगरेशन इस तरह से बनाया जाता है, ताकि डिवाइस पर मौजूद और B&A खरीदार, दोनों इसमें हिस्सा ले सकें:

await navigator.runAdAuction({
  seller: 'https://ssp-mix.example',
  decisionLogicURL: 'https://ssp-mix.example/score-ad.js',
  componentAuctions: [
    // B&A auction result
    {
      seller: 'https://ssp-mix.example',
      requestId,
      serverResponse: protectedAudienceAuctionResult,
    },
    // On-device auction config
    {
      seller: 'https://ssp-mix.example',
      decisionLogicURL: 'https://ssp-mix.example/on-device-score-ad.js',
      interestGroupBuyers: [
        'https://dsp-a.example', // On-device buyer
        'https://dsp-a.example', // On-device buyer
      ],
    },
  ]
});

मिक्स-मोड वाली नीलामी को आसान बनाने के लिए, B&A नीलामी के नतीजे और डिवाइस पर होने वाली नीलामी के कॉन्फ़िगरेशन को componentAuctions फ़ील्ड में पास किया जाता है. मिक्स-मोड ऑक्शन में, टॉप-लेवल कॉन्फ़िगरेशन और कॉम्पोनेंट कॉन्फ़िगरेशन, दोनों के लिए seller की वैल्यू एक जैसी होती है.

इस कॉल का उदाहरण देखने के लिए, स्थानीय टेस्टिंग ऐप्लिकेशन का सेलर JavaScript कोड देखें.

एक से ज़्यादा सेलर वाली नीलामी

अगर आप टॉप-लेवल सेलर हैं और डिवाइस पर होने वाली, एक से ज़्यादा सेलर की नीलामी को मैनेज करते हैं, तो हर कॉम्पोनेंट सेलर, B&A नीलामी के नतीजे और डिवाइस पर होने वाली नीलामी के कॉन्फ़िगरेशन सबमिट करता है.

await navigator.runAdAuction({
  seller: 'https://ssp-top.example',
  decisionLogicURL: 'https://ssp-top.example/score-ad.js',
  componentAuctions: [
    // SSP-BA's B&A-only auction result
    {
      seller: 'https://ssp-ba.example',
      requestId: 'g8312cb2-da2d-4e9b-80e6-e13dec2a581c',
      serverResponse: Uint8Array(560) [193, 120, 4, …] // Encrypted B&A auction result
    },
    // SSP-MIX's B&A auction result
    {
      seller: 'https://ssp-mix.example',
      requestId: 'f5135cb2-da2d-4e9b-80e6-e13dec2a581c',
      serverResponse: Uint8Array(560) [133, 20, 4, …] // Encrypted B&A auction result
    }.
    // SSP-MIX's on-device auction config
    {
      seller: 'https://ssp-mix.example',
      interestGroupBuyers: ['https://dsp-a.example', 'https://dsp-b.example'],
      decisionLogicURL: 'https://ssp-mix.example/score-ad.js',
    }
    // SSP-OD's on-device auction config
    {
      seller: 'https://ssp-od.example',
      interestGroupBuyers: ['https://dsp-a.example', 'https://dsp-b.example'],
      decisionLogicURL: 'https://ssp-od.example/score-ad.js',
    }
  ]
})

इस कॉल का उदाहरण देखने के लिए, स्थानीय टेस्टिंग ऐप्लिकेशन का सेलर JavaScript कोड देखें.

अगले चरण

इस गाइड को पढ़ने के बाद, ये काम किए जा सकते हैं:

ज़्यादा जानें

क्या आपका कोई सवाल है?