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

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

ध्यान दें: इस गाइड में यह माना गया है कि पाठक को, डिवाइस पर सुरक्षित ऑडियंस के फ़्लो के बारे में जानकारी है. हमारा सुझाव है कि इस गाइड को पढ़ने से पहले, B&A के आर्किटेक्चर की गाइड भी पढ़ें.

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

इस प्रोसेस को इस तरह समझा जा सकता है:

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

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

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

SAS को यूनिफ़ाइड नीलामी का अनुरोध भेजना

यूनिफ़ाइड नीलामी का अनुरोध, एक ऐसा अनुरोध होता है जिसमें प्लैटेक्स्ट कॉन्टेक्स्ट वाली नीलामी का पेलोड और PA B&A नीलामी का पेलोड शामिल होता है. 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 नीलामी पेलोड, जिसे SAS से SFE को भेजा जाना है, ताकि सर्वर-साइड बिडिंग ऐंड ऑप्टिमाइज़ेशन (बीए) नीलामी को चलाया जा सके.

इस कॉल का उदाहरण देखने के लिए, स्थानीय टेस्टिंग ऐप्लिकेशन का सेलर 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 को कॉल करें

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

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 में कोड में बदला गया था, तो SFE को gRPC का इस्तेमाल करके अनुरोध भेजने पर, उसे फिर से बाइनरी डेटा में डिकोड करना होगा. अगर अनुरोध एचटीटीपी का इस्तेमाल करके भेजा जाता है, तो एन्क्रिप्ट (सुरक्षित) किया गया विज्ञापन नीलामी डेटा, अपने बेस64-कोड में रह सकता है.

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',
  }
}

SFE के SelectAd पर कॉल करें

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

gRPC कॉल

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

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 को जोड़ा जाना चाहिए:

• Accept-Language
• User-Agent
• आईपी पता

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

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

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

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 को भेजा जाता है. इसके बाद, 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() को कॉल करें

SAS से मिलने वाले यूनिफ़ाइड ऑक्शन रिस्पॉन्स में, एन्क्रिप्ट (सुरक्षित) की गई बिडिंग ऐंड ऑप्टिमाइज़ेशन (बीए) ऑक्शन का नतीजा शामिल होता है. ब्राउज़र में नीलामी पूरी करने के लिए, इस पेलोड को 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 ऑक्शन चलाने के लिए, जहां डिवाइस पर मौजूद और B&A खरीदार, दोनों हिस्सा ले सकते हैं, runAdAuction() कॉल के ऑक्शन कॉन्फ़िगरेशन को इस तरह बनाया जाता है:

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 कोड देखें.

अगले चरण

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

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

• ज़्यादा जानकारी के लिए, GitHub पर ये एक्सप्लेनर देखें:
  • Chrome में B&A API
  • B&A सिस्टम डिज़ाइन
  • B&A की मल्टी-सेलर नीलामी
  • B&A मिक्स्ड-मोड नीलामी
• वेब के लिए B&A आर्किटेक्चर के बारे में ज़्यादा जानें
• एंड-टू-एंड लोकल टेस्टिंग कोडलैब में दिया गया तरीका अपनाकर, B&A के साथ Protected Audience का इस्तेमाल करके एक्सपेरिमेंट करें.

कोई सवाल पूछना चाहते हैं?

• अगर आपको बिडिंग और नीलामी सेवाओं के बारे में कोई सवाल पूछना है, तो बिडिंग और नीलामी सेवाओं के रिपॉज़िटरी में कोई समस्या दर्ज करें.
• अगर आपको Privacy Sandbox के बारे में कोई सामान्य सवाल पूछना है, तो privacy-sandbox-dev-support रिपॉज़िटरी में कोई समस्या दर्ज करें.