Rotate ad creatives

Use a Shared Storage to determine what creative a user sees across sites.

The Shared Storage API is a Privacy Sandbox proposal for general purpose, cross-site storage, which supports many possible use cases. One such example is creative rotation, which is available to test in Chrome 104.0.5086.0 and later.

With creative rotation, you can store data, such as creative ID, view counts, and user interaction, to determine which creative users' see across different sites.

Run a Shared Storage worklet to select a URL from a provided list, based on the stored data, and then render that creative in a fenced frame. This can be used to select new ads or other content.

Try creative rotation

To experiment with creative rotation with Shared Storage, confirm you're using Chrome 104.0.5086.0 or later. Then enable the Privacy Sandbox Ads APIs experiment flag at chrome://flags/#privacy-sandbox-ads-apis.

Set Privacy Sandbox Ads APIs experiment to enabled to use these APIs

You can also enable Shared Storage with the --enable-features=PrivacySandboxAdsAPIsOverride,OverridePrivacySandboxSettingsLocalTesting,SharedStorageAPI,FencedFrames flag in the command line.

Experiment with code samples

An advertiser or a content producer may want to apply different strategies to a campaign, and rotate the contents or creatives to increase effectiveness. Shared storage can be used to run different rotation strategies, such as sequential rotation and evenly-distributed rotation, across different sites.

In this example:

  • creative-rotation.js is embedded in a frame. This script sets which ads are the most important ( weight), and calls to the worklet to determine which content should be displayed.
  • creative-rotation-worklet.js is the shared storage worklet that determines the weighted distribution for the contents and returns which should be displayed.


// Ad config with the URL of the content, a probability weight for rotation, and the clickthrough rate.
    url: 'https://your-server.example/contents/content-1.html',
    weight: 0.7,
    url: 'https://your-server.example/contents/content-2.html',
    weight: 0.2,
    url: 'https://your-server.example/contents/content-3.html',
    weight: 0.1,

// Set the mode to sequential and set the starting index to 0.
async function seedStorage() {
  await window.sharedStorage.set('content-rotation-mode', 'sequential', {
    ignoreIfPresent: true,

  await window.sharedStorage.set('content-rotation-index', 0, {
    ignoreIfPresent: true,

async function injectAd() {
  // Load the worklet module
  await window.sharedStorage.worklet.addModule('content-rotation-worklet.js');

  // Initially set the storage to sequential mode for the demo

  // Run the URL selection operation to determine the next content rendered.
  const urls ={ url }) => ({ url }));
  const fencedFrameConfig = await window.sharedStorage.selectURL('content-rotation', urls, { 
    resolveToConfig: true

  // Render the opaque URL into a fenced frame
  document.getElementById('content-slot').config = fencedFrameConfig;



class SelectURLOperation {
  async run(urls, data) {
    // Read the rotation mode from Shared Storage
    const rotationMode = await this.sharedStorage.get('content-rotation-mode');

    // Generate a random number to be used for rotation
    const randomNumber = Math.random();

    let index;

    switch (rotationMode) {
       * Sequential rotation
       * - Rotates the contents in order
       * - Example: A -> B -> C -> A ...
      case 'sequential':
        const currentIndex = await this.sharedStorage.get('creative-rotation-index');
        index = parseInt(currentIndex, 10);
        const nextIndex = (index + 1) % urls.length;

        await this.sharedStorage.set('content-rotation-index', nextIndex);

       * Weighted rotation
       * - Rotates the contentswith weighted probability
       * - Example: A=70% / B=20% / C=10%
      case 'weighted-distribution':
        // Sum the weights cumulatively, and find the first URL where the
        // sum exceeds the random number. The array is sorted in
        // descending order first.
        let weightSum = 0;
        const { url } = data
          .sort((a, b) => b.weight - a.weight)
          .find(({ weight }) => {
            weightSum += weight;
            return weightSum > randomNumber;

        index = urls.indexOf(url);

        index = 0;
    return index;

register('content-rotation', SelectURLOperation);

Use cases

These are only some of the possible use cases for Shared Storage. We'll continue to add examples as we receive feedback and discover new use cases.

Content selection

Select and display different content on different websites in fenced frames based on information collected in Shared Storage. The output gate for these use cases is URL selection.

  • Creative rotation: Store data, such as creative ID, view counts, and user interaction, to determine which creative users' see across different sites.
  • A/B testing: You can assign a user to an experiment group, then store that group in Shared Storage to be accessed cross-site.
  • Custom user experiences: Share custom content and calls-to-action based on a user's registration status or other user states

Generate summary reports

Collect information with Shared Storage and generated a noisy, aggregated summary report. The output gate for these use cases is the Private Aggregation API.

  • Unique reach measurement: Many content producers and advertisers want to know how many unique people saw their content. Use Shared Storage to record the first time a user saw your ad, embedded video, or publication, and prevent duplicative counting of that same user on different sites. You can then use the Private Aggregation API to output a summary report for your reach.
  • Demographics measurement: Content producers often want to understand the demographics of their audience. You can use Shared Storage to record user demographic data in a context where you have it, such as your first-party site, and use aggregated reporting to report on it across many other sites, such as embedded content.
  • K+ frequency measurement: Sometimes described as "effective frequency," there is often a minimum number views before a user will recognize or recall certain content (often in the context of advertisement views). You can use Shared Storage to build reports of unique users that have seen a piece of content at least K number of times.

Engage and share feedback

The Shared Storage proposal is under active discussion and subject to change in the future. If you try this API and have feedback, we'd love to hear it.