The News Site That Chose the Wrong CMP

Illustrative scenario: a composite example, not a specific reported case.

A major online news publisher switched to a "simpler" consent management platform—one marketed primarily to e-commerce sites. The banner looked cleaner. The implementation was easier. The consent rate improved.

Then their programmatic ad revenue dropped 40% overnight.

The problem: the e-commerce CMP didn't properly implement IAB TCF 2.2. It collected consent, but it didn't generate the TC String that ad exchanges need to verify user choices. Google Ad Manager, Prebid partners, and major SSPs all stopped bidding on their inventory. They couldn't verify consent through the standard API, so they treated every impression as unconsented.

The publisher scrambled to switch back to a TCF-compliant CMP. By the time they recovered, they'd lost €180,000 in ad revenue. The "simple" solution had been catastrophically wrong for their business model.

---

title: "CMP for Publishers vs E-commerce: Complete Requirements Guide 2025" slug: "cmp-publishers-vs-ecommerce-requirements" excerpt: "Discover why publishers and e-commerce sites need fundamentally different consent management platforms. Learn about IAB TCF requirements for ad-funded sites, UX optimization for retail, and how to choose the right CMP for your business model." category: "Consent Management" tags: ["CMP", "Publishers", "E-commerce", "IAB TCF", "Consent Management", "Programmatic Advertising"] publishedAt: "2025-01-19" readTime: "20 min read"

CMP for Publishers vs E-commerce: Complete Requirements Guide

The consent management platform you choose can make or break your business. For publishers, the wrong CMP means ad exchanges refuse to bid on your inventory, killing revenue. For e-commerce sites, an overly complex banner drives away customers before they even see your products. Understanding the fundamental differences between these two use cases is essential for making the right technology choice.

Why One Size Doesn't Fit All

At first glance, cookie consent seems like a solved problem—display a banner, collect consent, move on. But the reality is far more nuanced. Publishers and e-commerce sites have completely different relationships with their users, different revenue models, and different regulatory exposure.

The Publisher Reality: TCF or Die

For publishers relying on programmatic advertising, consent isn't just about compliance—it's about revenue. Ad exchanges like Google AdX, Prebid partners, and demand-side platforms require valid IAB Transparency & Consent Framework (TCF) signals. Without them, they simply won't bid on your inventory.

Consider this scenario: a news publisher implementing a simple "Accept/Reject" banner sees programmatic ad revenue fall sharply. Why? Because major ad buyers couldn't verify consent through the TCF API, so they stopped bidding entirely.

The E-commerce Reality: Conversion Optimization

E-commerce sites face the opposite problem. Their primary revenue comes from product sales, not advertising. A complex, multi-screen consent dialog that publishers need for TCF compliance becomes a conversion killer for online stores.

Every extra step before checkout costs some conversions. A consent banner that requires users to review 500+ vendors before shopping creates massive friction that directly impacts sales.

Understanding IAB TCF Requirements for Publishers

The IAB TCF is a standardized framework that enables programmatic advertising while respecting user consent choices. For publishers, implementing TCF correctly is non-negotiable.

How TCF Works

// TCF v2.2 consent string structure
// The TC String encodes all consent choices in a compressed format

// Accessing the CMP API
__tcfapi('addEventListener', 2, function(tcData, success) {
    if (success && tcData.eventStatus === 'useractioncomplete') {
        // User has made their consent choices
        console.log('Consent string:', tcData.tcString);
        console.log('GDPR applies:', tcData.gdprApplies);
        console.log('Purpose consents:', tcData.purpose.consents);

        // Pass to ad tech
        googletag.cmd.push(function() {
            googletag.pubads().setRequestNonPersonalizedAds(
                tcData.purpose.consents[1] ? 0 : 1
            );
        });
    }
});

// Checking specific vendor consent
__tcfapi('getCustomVendorConsents', 2, function(data, success) {
    if (success) {
        // Check if specific vendor has consent
        const googleConsent = data.grants['755']; // Google's vendor ID
        if (googleConsent && googleConsent.vendorGrant) {
            // Can load Google advertising products
            loadGoogleAds();
        }
    }
});

TCF Purposes Explained

Publishers must obtain consent for specific purposes defined by the TCF:

Purpose ID	Name	Description	Impact on Ads
1	Store/access information	Basic cookie access	Required for all tracking
2	Select basic ads	Contextual advertising	Non-personalized ads
3	Create personalized ad profile	Build user profiles	Behavioral targeting
4	Select personalized ads	Use profiles for targeting	Personalized ads
5	Create content personalization profile	Content recommendations	Personalized content
6	Select personalized content	Use content profiles	Custom content
7	Measure ad performance	Attribution/reporting	Ad analytics
8	Measure content performance	Content analytics	Engagement metrics
9	Apply market research	Audience insights	Research panels
10	Develop and improve products	Product development	A/B testing

Publisher CMP Requirements

// Publisher-focused CMP configuration
interface PublisherCMPConfig {
    // TCF Requirements
    tcf: {
        enabled: true;
        version: '2.2';
        cmpId: number;  // Registered CMP ID
        cmpVersion: number;
        publisherCountryCode: string;

        // Vendor list configuration
        vendorList: {
            url: 'https://vendor-list.consensu.org/v3/vendor-list.json';
            cacheTime: 86400;  // 24 hours
        };

        // Publisher restrictions
        publisherRestrictions: {
            // Require consent (not legitimate interest) for these purposes
            requireConsent: [1, 2, 3, 4, 7];
            // Completely block certain vendors
            blockedVendors: number[];
            // Allow specific vendors for specific purposes only
            vendorPurposeRestrictions: Map<number, number[]>;
        };

        // Google Additional Consent Mode
        googleAdditionalConsent: {
            enabled: true;
            providers: number[];  // ATP provider IDs
        };
    };

    // Prebid.js integration
    prebid: {
        enabled: true;
        gdprEnforcement: {
            enforceVendors: true;
            enforcePurposes: true;
            consentTimeout: 3000;  // ms to wait for consent
        };
    };

    // Google Publisher Tag integration
    gpt: {
        enabled: true;
        nonPersonalizedAds: boolean;  // Default when no consent
        restrictDataProcessing: boolean;
    };
}

// Implementing for a publisher
class PublisherCMP {
    private config: PublisherCMPConfig;
    private tcModel: TCModel;
    private vendorList: GVL;

    async initialize(): Promise<void> {
        // Load Global Vendor List
        this.vendorList = await GVL.load();

        // Register with TCF
        this.registerTcfApi();

        // Initialize ad tech integrations
        await this.initializePrebid();
        await this.initializeGPT();

        // Display consent UI if needed
        if (await this.shouldShowConsent()) {
            await this.displayConsentUI();
        }
    }

    private registerTcfApi(): void {
        const tcfApi = (command: string, version: number, callback: Function, parameter?: any) => {
            switch (command) {
                case 'getTCData':
                    callback(this.getTCData(), true);
                    break;
                case 'ping':
                    callback(this.getPingData(), true);
                    break;
                case 'addEventListener':
                    this.addEventListener(callback);
                    break;
                case 'removeEventListener':
                    this.removeEventListener(parameter);
                    break;
            }
        };

        // Make available globally
        (window as any).__tcfapi = tcfApi;

        // Create queue for commands received before initialization
        (window as any).__tcfapi.queue = [];
    }

    private getTCData(): TCData {
        return {
            tcString: this.tcModel.toString(),
            tcfPolicyVersion: 4,
            cmpId: this.config.tcf.cmpId,
            cmpVersion: this.config.tcf.cmpVersion,
            gdprApplies: this.isGdprApplicable(),
            eventStatus: this.getEventStatus(),
            cmpStatus: 'loaded',
            listenerId: null,
            isServiceSpecific: true,
            useNonStandardTexts: false,
            publisherCC: this.config.tcf.publisherCountryCode,
            purposeOneTreatment: false,
            purpose: {
                consents: this.tcModel.purposeConsents.toObject(),
                legitimateInterests: this.tcModel.purposeLegitimateInterests.toObject()
            },
            vendor: {
                consents: this.tcModel.vendorConsents.toObject(),
                legitimateInterests: this.tcModel.vendorLegitimateInterests.toObject()
            },
            specialFeatureOptins: this.tcModel.specialFeatureOptins.toObject(),
            publisher: {
                consents: this.tcModel.publisherConsents.toObject(),
                legitimateInterests: this.tcModel.publisherLegitimateInterests.toObject(),
                customPurpose: {
                    consents: this.tcModel.publisherCustomConsents.toObject(),
                    legitimateInterests: this.tcModel.publisherCustomLegitimateInterests.toObject()
                },
                restrictions: this.tcModel.publisherRestrictions.toObject()
            }
        };
    }

    private async initializePrebid(): Promise<void> {
        if (!this.config.prebid.enabled) return;

        // Wait for Prebid.js to load
        await this.waitForPrebid();

        // Configure GDPR module
        (window as any).pbjs.que.push(() => {
            (window as any).pbjs.setConfig({
                consentManagement: {
                    gdpr: {
                        cmpApi: 'iab',
                        timeout: this.config.prebid.gdprEnforcement.consentTimeout,
                        defaultGdprScope: true,
                        rules: [{
                            purpose: 'basicAds',
                            enforcePurpose: this.config.prebid.gdprEnforcement.enforcePurposes,
                            enforceVendor: this.config.prebid.gdprEnforcement.enforceVendors
                        }]
                    }
                }
            });
        });
    }

    private async initializeGPT(): Promise<void> {
        if (!this.config.gpt.enabled) return;

        // Configure Google Publisher Tags
        (window as any).googletag = (window as any).googletag || { cmd: [] };

        (window as any).googletag.cmd.push(() => {
            const pubads = (window as any).googletag.pubads();

            // Set initial state based on consent
            if (!this.hasConsent()) {
                pubads.setRequestNonPersonalizedAds(1);
                pubads.setPrivacySettings({
                    restrictDataProcessing: this.config.gpt.restrictDataProcessing
                });
            }
        });
    }

    async displayConsentUI(): Promise<void> {
        // Publishers need granular control
        const ui = new ConsentUI({
            mode: 'layered',  // First layer overview, second layer details
            vendorDisplay: 'full',  // Show all 800+ vendors
            purposeDisplay: 'expanded',
            features: {
                searchVendors: true,
                filterByPurpose: true,
                vendorDetails: true,  // Show privacy policies
                legitimateInterestControls: true
            }
        });

        const consent = await ui.show();
        await this.saveConsent(consent);
    }
}

E-commerce CMP Requirements: Optimizing for Conversion

E-commerce sites have fundamentally different priorities. While compliance is still mandatory, the focus shifts from ad revenue to minimizing friction in the purchase journey.

The E-commerce Consent Challenge

// E-commerce consent impact study data
const consentImpactMetrics = {
    // Banner complexity vs conversion impact
    simpleAcceptReject: {
        consentRate: 85,
        bounceRateIncrease: 2,
        cartAbandonmentImpact: 0.5
    },
    categoryBasedConsent: {
        consentRate: 72,
        bounceRateIncrease: 5,
        cartAbandonmentImpact: 1.2
    },
    fullVendorList: {
        consentRate: 45,
        bounceRateIncrease: 18,
        cartAbandonmentImpact: 4.8
    }
};

E-commerce CMP Configuration

// E-commerce focused CMP configuration
interface EcommerceCMPConfig {
    // Simplified consent model
    consent: {
        model: 'category';  // Not vendor-level
        categories: {
            essential: {
                name: 'Essential';
                description: 'Required for shopping cart and checkout';
                required: true;
                scripts: ['cart', 'checkout', 'security'];
            };
            analytics: {
                name: 'Analytics';
                description: 'Help us improve your shopping experience';
                default: false;
                scripts: ['google-analytics', 'hotjar'];
            };
            marketing: {
                name: 'Marketing';
                description: 'Personalized product recommendations';
                default: false;
                scripts: ['facebook-pixel', 'google-ads', 'criteo'];
            };
            functional: {
                name: 'Preferences';
                description: 'Remember your preferences and recently viewed';
                default: true;
                scripts: ['recently-viewed', 'wishlist', 'currency'];
            };
        };
    };

    // Google Consent Mode (not full TCF)
    googleConsentMode: {
        enabled: true;
        defaults: {
            analytics_storage: 'denied';
            ad_storage: 'denied';
            ad_user_data: 'denied';
            ad_personalization: 'denied';
            functionality_storage: 'granted';
            personalization_storage: 'denied';
            security_storage: 'granted';
        };
        waitForUpdate: 500;  // Wait 500ms for consent
    };

    // UX optimization
    ux: {
        position: 'bottom-bar';  // Not modal/full-screen
        blocking: false;  // Don't block interaction
        animation: 'slide-up';
        autoHide: false;  // Never auto-hide without consent
        focusOnFirst: false;  // Don't trap focus
        mobileOptimized: true;
        brandColors: true;  // Match site branding
    };

    // Conversion protection
    conversion: {
        neverBlockCheckout: true;
        allowCartWithoutConsent: true;
        delayBannerOnCheckout: true;  // Don't show on checkout
        softBarrierOnly: true;  // No hard blocking
    };
}

// Implementing for e-commerce
class EcommerceCMP {
    private config: EcommerceCMPConfig;
    private consentState: ConsentState;

    async initialize(): Promise<void> {
        // Check if we're in a protected flow
        if (this.isCheckoutPage()) {
            // Minimize consent friction during checkout
            this.delayConsentBanner();
        }

        // Initialize Google Consent Mode with defaults
        this.initializeGoogleConsentMode();

        // Load existing consent or show banner
        const existingConsent = this.loadConsent();
        if (existingConsent) {
            this.applyConsent(existingConsent);
        } else if (!this.isCheckoutPage()) {
            this.displayBanner();
        }
    }

    private initializeGoogleConsentMode(): void {
        // Initialize with denied defaults
        window.dataLayer = window.dataLayer || [];
        function gtag(...args: any[]) {
            window.dataLayer.push(args);
        }

        gtag('consent', 'default', this.config.googleConsentMode.defaults);

        // Set wait time for consent update
        gtag('set', 'ads_data_redaction', true);
        gtag('set', 'url_passthrough', true);
    }

    private displayBanner(): void {
        const banner = this.createBannerElement();

        // E-commerce optimized styling
        banner.innerHTML = `
            <div class="cookie-banner-content">
                <div class="cookie-banner-text">
                    <h3>Your Privacy Matters</h3>
                    <p>We use cookies to enhance your shopping experience and show you relevant products.</p>
                </div>
                <div class="cookie-banner-actions">
                    <button class="btn btn-secondary" data-action="customize">
                        Customize
                    </button>
                    <button class="btn btn-primary" data-action="accept-all">
                        Accept All
                    </button>
                </div>
            </div>
        `;

        // Non-blocking positioning
        banner.style.cssText = `
            position: fixed;
            bottom: 0;
            left: 0;
            right: 0;
            background: white;
            box-shadow: 0 -4px 20px rgba(0,0,0,0.1);
            z-index: 9999;
            padding: 16px 24px;
            transform: translateY(100%);
            transition: transform 0.3s ease;
        `;

        document.body.appendChild(banner);

        // Animate in
        requestAnimationFrame(() => {
            banner.style.transform = 'translateY(0)';
        });

        // Setup event listeners
        this.setupBannerEvents(banner);
    }

    private setupBannerEvents(banner: HTMLElement): void {
        banner.addEventListener('click', async (e) => {
            const target = e.target as HTMLElement;
            const action = target.dataset.action;

            switch (action) {
                case 'accept-all':
                    await this.acceptAll();
                    this.hideBanner(banner);
                    break;
                case 'customize':
                    await this.showCustomizeModal();
                    break;
            }
        });
    }

    private async acceptAll(): Promise<void> {
        const consent = {
            essential: true,
            analytics: true,
            marketing: true,
            functional: true,
            timestamp: Date.now()
        };

        await this.saveAndApplyConsent(consent);
    }

    private async saveAndApplyConsent(consent: ConsentState): Promise<void> {
        // Save to cookie
        this.saveConsent(consent);

        // Update Google Consent Mode
        window.dataLayer.push({
            'event': 'consent_update',
            'analytics_storage': consent.analytics ? 'granted' : 'denied',
            'ad_storage': consent.marketing ? 'granted' : 'denied',
            'ad_user_data': consent.marketing ? 'granted' : 'denied',
            'ad_personalization': consent.marketing ? 'granted' : 'denied',
            'functionality_storage': 'granted',
            'personalization_storage': consent.functional ? 'granted' : 'denied'
        });

        // Load approved scripts
        await this.loadConsentedScripts(consent);
    }

    private async loadConsentedScripts(consent: ConsentState): Promise<void> {
        const scriptLoader = new ScriptLoader();

        if (consent.analytics) {
            await scriptLoader.load([
                { id: 'ga4', src: 'https://www.googletagmanager.com/gtag/js?id=G-XXXXXX' },
            ]);
        }

        if (consent.marketing) {
            await scriptLoader.load([
                { id: 'fb-pixel', src: 'https://connect.facebook.net/en_US/fbevents.js' },
            ]);
        }
    }

    private async showCustomizeModal(): Promise<void> {
        const modal = new ConsentModal({
            categories: this.config.consent.categories,
            currentConsent: this.consentState,
            onSave: async (consent) => {
                await this.saveAndApplyConsent(consent);
                modal.close();
                this.hideBanner(document.querySelector('.cookie-banner'));
            }
        });

        modal.show();
    }

    private isCheckoutPage(): boolean {
        const checkoutPatterns = [
            /\/checkout/,
            /\/cart/,
            /\/payment/,
            /\/order-confirmation/
        ];
        return checkoutPatterns.some(p => p.test(window.location.pathname));
    }
}

Feature Comparison: Publisher vs E-commerce CMPs

Feature	Publisher CMP	E-commerce CMP	Why It Matters
IAB TCF Support	Required	Optional	Publishers need TCF for programmatic ads
Vendor List	Full (800+ vendors)	Minimal (10-20)	E-commerce doesn't need ad tech vendors
Consent Granularity	Vendor + Purpose	Category only	Simpler = higher consent rates
Legitimate Interest	Required	Rarely used	TCF requires LI handling
Banner Complexity	Multi-layer required	Single layer preferred	UX optimization differs
Integration Points	Prebid, GAM, SSPs	GA4, Meta, Shopify	Different tech stacks
Consent Recovery	TC String	Simple cookie	Different storage needs
A/B Testing	Limited by TCF	Extensive	Conversion optimization

Choosing the Right CMP Vendor

Top Publisher CMPs

1. Sourcepoint

• Full TCF 2.2 compliance
• Advanced vendor management
• Built-in prebid integration
• Custom messaging capabilities

// Sourcepoint initialization
window._sp_queue = [];
window._sp_ = {
    config: {
        accountId: 123,
        propertyId: 456,
        gdpr: {
            targetingAllowed: true,
            consentLanguage: 'EN'
        },
        events: {
            onConsentReady: function(consentUUID, euconsent) {
                // Pass to ad stack
                window.googletag.cmd.push(function() {
                    window.googletag.pubads().refresh();
                });
            }
        }
    }
};

2. Quantcast Choice

• Free for publishers
• Easy setup
• Google CMP partner
• Good for smaller publishers

3. OneTrust

• Enterprise-grade
• Multi-regulation support
• Advanced analytics
• Higher price point

Top E-commerce CMPs

1. Cookiebot (Cybot)

• Automatic cookie scanning
• Easy Shopify/WooCommerce integration
• Google Consent Mode native
• Affordable pricing

// Cookiebot initialization for e-commerce
window.addEventListener('CookiebotOnAccept', function() {
    if (Cookiebot.consent.marketing) {
        // Load Facebook Pixel
        fbq('init', 'YOUR_PIXEL_ID');
        fbq('track', 'PageView');
    }
    if (Cookiebot.consent.statistics) {
        // Initialize GA4
        gtag('config', 'G-XXXXXX');
    }
});

2. CookieYes

• Visual customization
• Low cost
• Good for small/medium stores
• CCPA support

3. Osano

• Consent + data mapping
• Privacy compliance suite
• Enterprise features
• Higher complexity

Implementation Best Practices

For Publishers: Maximizing Ad Revenue

// Publisher revenue optimization strategy
class PublisherConsentOptimization {
    // Strategy 1: Consent recovery
    async attemptConsentRecovery(): Promise<void> {
        // If user rejected, offer value proposition
        if (this.wasConsentRejected()) {
            const daysSinceRejection = this.getDaysSinceRejection();

            if (daysSinceRejection >= 30) {
                // Re-prompt with better messaging
                await this.showConsentRecoveryDialog({
                    message: 'Support our journalism by allowing personalized ads',
                    incentive: 'Get 2 free premium articles'
                });
            }
        }
    }

    // Strategy 2: Progressive consent
    async progressiveConsent(): Promise<void> {
        // Start with basic consent
        const basicConsent = await this.getBasicConsent();

        if (basicConsent.essential) {
            // After engagement, ask for more
            this.onEngagement(async () => {
                await this.requestAdditionalConsent([
                    'personalized_ads',
                    'audience_measurement'
                ]);
            });
        }
    }

    // Strategy 3: Contextual fallback
    setupContextualFallback(): void {
        if (!this.hasFullConsent()) {
            // Load contextual-only ad configuration
            window.googletag.cmd.push(() => {
                window.googletag.pubads().setRequestNonPersonalizedAds(1);
            });

            // Use non-TCF demand sources
            this.enableContextualDemand([
                'carbon',
                'buysellads',
                'tribal'
            ]);
        }
    }
}

For E-commerce: Maximizing Conversions

// E-commerce conversion optimization
class EcommerceConsentOptimization {
    // Strategy 1: Smart timing
    smartBannerTiming(): void {
        // Don't show immediately
        setTimeout(() => {
            if (!this.isInPurchaseFlow()) {
                this.showBanner();
            }
        }, 3000);  // 3 second delay

        // Or trigger on scroll
        window.addEventListener('scroll', () => {
            if (window.scrollY > 500 && !this.bannerShown) {
                this.showBanner();
            }
        }, { once: true });
    }

    // Strategy 2: Exit intent for rejectors
    setupExitIntentRecovery(): void {
        document.addEventListener('mouseleave', (e) => {
            if (e.clientY < 50 && this.wasConsentRejected()) {
                this.showExitIntentOffer({
                    message: '10% off your first order when you accept cookies!',
                    code: 'COOKIE10'
                });
            }
        });
    }

    // Strategy 3: Soft consent barriers
    softConsentBarrier(): void {
        // Allow browsing but prompt before key actions
        this.onAction('add-to-cart', async () => {
            if (!this.hasConsent()) {
                const consented = await this.showInlineConsent({
                    context: 'To save items to your cart, we use essential cookies.'
                });

                return consented;  // Block action if declined
            }
            return true;
        });
    }

    // Strategy 4: Personalization preview
    showPersonalizationBenefit(): void {
        // Show what they're missing without marketing consent
        if (!this.consent.marketing) {
            document.querySelector('.product-recommendations').innerHTML = `
                <div class="personalization-preview">
                    <p>Enable personalized recommendations to see products you'll love</p>
                    <button onclick="CMP.requestMarketingConsent()">
                        Enable Recommendations
                    </button>
                </div>
            `;
        }
    }
}

Testing and Compliance Verification

Publisher Compliance Testing

// TCF compliance test suite
describe('Publisher TCF Compliance', () => {
    test('TCF API is available', () => {
        expect(window.__tcfapi).toBeDefined();
    });

    test('TC String is valid', async () => {
        const tcData = await getTCData();
        expect(tcData.tcString).toMatch(/^[A-Za-z0-9_-]+$/);
        expect(tcData.tcfPolicyVersion).toBeGreaterThanOrEqual(4);
    });

    test('Vendor consent is properly stored', async () => {
        const tcData = await getTCData();
        // Google (ID: 755) should be in vendor list
        expect(tcData.vendor.consents).toHaveProperty('755');
    });

    test('Prebid receives valid consent', async () => {
        const prebidConsent = await getPrebidConsent();
        expect(prebidConsent.gdprApplies).toBeDefined();
        expect(prebidConsent.consentString).toBeTruthy();
    });

    test('Ad refresh respects consent', async () => {
        // Reject consent
        await rejectAllConsent();

        // Verify non-personalized ads
        const adRequest = await captureAdRequest();
        expect(adRequest.npa).toBe(1);
    });
});

E-commerce Compliance Testing

// E-commerce consent test suite
describe('E-commerce Consent Compliance', () => {
    test('Checkout works without consent', async () => {
        // Clear all consent
        await clearConsent();

        // Add product to cart
        await addToCart('product-123');
        expect(await getCartCount()).toBe(1);

        // Navigate through checkout
        await goToCheckout();
        expect(page.url()).toContain('/checkout');

        // Should not be blocked by consent
        expect(await isCheckoutBlocked()).toBe(false);
    });

    test('Analytics blocked without consent', async () => {
        await rejectAnalyticsConsent();

        // GA should not fire
        const gaRequests = await captureNetworkRequests('google-analytics.com');
        expect(gaRequests).toHaveLength(0);
    });

    test('Google Consent Mode signals correct', async () => {
        await acceptOnlyEssential();

        const consentState = await getGoogleConsentState();
        expect(consentState.analytics_storage).toBe('denied');
        expect(consentState.ad_storage).toBe('denied');
    });

    test('Marketing pixels respect consent', async () => {
        await rejectMarketingConsent();

        // Facebook pixel should not fire
        const fbRequests = await captureNetworkRequests('facebook.com');
        expect(fbRequests).toHaveLength(0);

        // Now accept
        await acceptMarketingConsent();

        // Pixel should fire
        await page.reload();
        const fbRequestsAfter = await captureNetworkRequests('facebook.com');
        expect(fbRequestsAfter.length).toBeGreaterThan(0);
    });
});

Common Mistakes to Avoid

Publisher Mistakes

1. Using a simple banner for TCF

   • Ad exchanges need TCF strings, not just accept/reject

2. Not updating vendor lists

   • Global Vendor List updates weekly; stale lists break compliance

3. Ignoring legitimate interest

   • TCF requires handling LI separately from consent

4. Blocking content before consent

   • Users must be able to access content; ads can be replaced

E-commerce Mistakes

1. Using a publisher CMP

   • Overly complex for e-commerce needs, hurts conversions

2. Blocking checkout without consent

   • Essential cookies for cart/checkout don't require consent

3. Identical mobile experience

   • Mobile consent UI needs smaller footprint

4. Ignoring consent-less tracking alternatives

   • Google Consent Mode allows modeling without consent

Finding the Right Fit

The choice between a publisher CMP and an e-commerce CMP is not about which is "better"—it's about which is appropriate for your business model. Publishers need TCF compliance to maintain ad revenue, which requires complex vendor management and multi-layer consent interfaces. E-commerce sites need streamlined consent flows that don't impede the purchase journey.

Key takeaways:

1. Publishers: Invest in a TCF-compliant CMP with deep ad tech integrations. Sourcepoint, Quantcast Choice, or OneTrust are solid choices. Accept that some UI complexity is necessary for revenue protection.

2. E-commerce: Prioritize UX and conversion optimization. Cookiebot, CookieYes, or a custom solution focused on Google Consent Mode integration. Never let consent block checkout.

3. Hybrid sites: If you're both a publisher and sell products, consider separate consent strategies for different sections of your site, or use a flexible CMP that supports both use cases.

Remember: compliance is the floor, not the ceiling. The best consent implementation is one that respects user choice while supporting your business model. Measure, test, and iterate based on both compliance audits and business metrics.