Ad stacking

How Ad stacking Works

     User's View      │      Fraudulent Publisher's Site/App
──────────────────────┼─────────────────────────────────────────────
                      │
   Visible Ad         │   +─────────────────────+
 [ Ad Campaign #1 ]   │   │   Visible Ad Slot   │  ← User sees this ad
 └──────────────────┘ │   +─────────────────────+
                      │             ↑
                      │      Loads & Hides
                      │             ↓
   Hidden Layers      │   +─────────────────────+
   (Invisible)        │   │   Hidden Ad #2      │  ← Impression #2 logged
                      │   +─────────────────────+
                      │   │   Hidden Ad #3      │  ← Impression #3 logged
                      │   +─────────────────────+
                      │   │   ... (more ads)    │  ← More impressions
                      │   +─────────────────────+
                      │

Ad stacking is a deceptive technique used in digital advertising to defraud advertisers. It involves placing multiple ads on top of each other within a single ad slot on a website or mobile app. While only the topmost ad is visible to the end-user, all the ads in the stack, including the hidden ones, register an impression. This leads to advertisers being billed for ads that were never actually seen.

The Layering Mechanism

Fraudulent publishers or networks use code (like CSS or iframes) to control the visibility of ads within a single placement. They might set the opacity of the ads underneath to zero or place them in a 1×1 pixel, making them invisible. When a user visits the page, the browser loads all the ads in the stack. Each ad’s tracking pixel fires, sending an impression count back to the respective ad server, even though only one ad is in the viewable area. This technique is especially common in cost-per-mille (CPM) campaigns where payment is based on the number of impressions.

Triggering Clicks and Impressions

In many ad stacking scenarios, the primary goal is to inflate impression counts. However, it can also be used to generate fraudulent clicks. A single click on the visible top ad can be programmed to register as a click on all the ads layered beneath it. This is often accomplished through scripts that propagate the click event to all layers. This practice significantly distorts campaign metrics, showing high impression volumes and sometimes impossible click-through rates, while providing no real engagement or return on ad spend (ROAS).

Bypassing Viewability Standards

Ad stacking directly undermines ad viewability, a key metric that measures whether an ad had the opportunity to be seen. While some sophisticated viewability tools can detect such fraud, basic implementations might only check if a pixel has loaded, not if it’s genuinely visible to a human eye. Fraudsters exploit this loophole to make it appear that their inventory is performing well, thereby attracting more advertisers and illegitimately earning revenue.

Breakdown of the ASCII Diagram

User’s View vs. Publisher’s Site

The diagram separates the user’s perspective from the technical reality on the publisher’s fraudulent page. The user sees only one legitimate-looking ad (“Visible Ad”), unaware of the hidden layers beneath it. This separation highlights the deceptive nature of the fraud, as the user experience remains normal while the fraud occurs in the background.

The Stacking Logic

The elements under “Fraudulent Publisher’s Site/App” illustrate the core mechanism. The “Visible Ad Slot” is the container. The arrows indicating “Loads & Hides” show the fraudulent action of rendering multiple ads while only allowing one to be seen. Each “Hidden Ad” box represents an ad from a different campaign that gets loaded and registers an impression, even though it is completely obscured. This visualizes how costs are inflated for advertisers.

🧠 Core Detection Logic

Example 1: Timestamp Correlation

This logic detects ad stacking by identifying multiple ad interactions (clicks or impressions) originating from the same device or user session at the exact same time. Since a legitimate user cannot interact with multiple ads in different locations simultaneously, identical timestamps are a strong indicator of stacking.

FUNCTION detect_stacking(session_logs):
  // Group all ad events by user session ID
  grouped_events = GROUP_BY(session_logs, "session_id")

  FOR each session in grouped_events:
    // Further group events by their exact timestamp
    timed_events = GROUP_BY(session.events, "timestamp")

    FOR each time_group in timed_events:
      // If more than one unique ad ID exists for a single timestamp, flag it
      IF COUNT(UNIQUE(time_group.ad_id)) > 1:
        FLAG_AS_FRAUD(session.id, "Ad Stacking Detected: Multiple ads at same timestamp")
        RETURN

Example 2: Viewability and Geometry Analysis

This method checks the viewability status and physical position of ad containers on a webpage. If multiple ad containers report being 100% viewable but share the exact same coordinates and dimensions, it implies they are stacked on top of each other. This requires a client-side script that can access the DOM.

FUNCTION check_ad_geometry(ad_containers):
  // Store geometry of checked containers: { "x,y,w,h": count }
  geometry_map = {}

  FOR ad in ad_containers:
    // Check if the ad is considered viewable by the browser's API
    IF ad.is_viewable():
      // Create a unique key from the ad's position and size
      geo_key = CONCAT(ad.x, ad.y, ad.width, ad.height)

      // Increment count for this specific geometry
      IF geo_key in geometry_map:
        geometry_map[geo_key] += 1
      ELSE:
        geometry_map[geo_key] = 1

  // If any geometry has more than one ad, it's a stack
  FOR key, count in geometry_map.items():
    IF count > 1:
      FLAG_AS_FRAUD("Ad Stacking Detected: Overlapping geometry")
      RETURN

Example 3: Impression-to-Click Ratio Anomaly

This server-side logic analyzes the performance metrics of a specific ad placement or publisher. Placements committing ad stacking fraud often exhibit an abnormally high number of impressions with a near-zero click-through rate (CTR) because the hidden ads are never seen and therefore cannot be clicked.

FUNCTION analyze_placement_performance(publisher_id, time_window):
  placement_data = GET_DATA(publisher_id, time_window)

  FOR each placement in placement_data:
    impressions = placement.impression_count
    clicks = placement.click_count

    // Set a high threshold for impressions and a very low one for CTR
    HIGH_IMPRESSION_THRESHOLD = 10000
    LOW_CTR_THRESHOLD = 0.0001 // 0.01%

    IF impressions > HIGH_IMPRESSION_THRESHOLD:
      ctr = clicks / impressions
      IF ctr < LOW_CTR_THRESHOLD:
        FLAG_AS_FRAUD(publisher_id, placement.id, "Anomaly Detected: Extremely high impressions with near-zero CTR")

📈 Practical Use Cases for Businesses

• Campaign Budget Shielding – Prevents ad spend from being wasted on fraudulent, unseen impressions, ensuring that budget is allocated to ads with a genuine opportunity to be viewed by human users.
• Data Integrity for Analytics – By filtering out fraudulent impressions and clicks from stacking, businesses can maintain clean performance data, leading to more accurate analysis and better strategic marketing decisions.
• Improving Return on Ad Spend (ROAS) – Eliminating payments for fake impressions directly improves ROAS by ensuring that the ad spend is directed towards legitimate placements that can drive actual conversions.
• Protecting Brand Reputation – Prevents brand association with low-quality or fraudulent publishers, preserving brand safety and ensuring ads are displayed in appropriate environments.

Example 1: Real-Time Impression Timestamp Rule

This pseudocode defines a real-time rule within an ad exchange or a demand-side platform (DSP) to block bids to publishers that show signs of ad stacking. It works by flagging users who generate multiple impressions from different ad campaigns simultaneously.

// Rule: Block bid request if user exhibits stacking behavior

FUNCTION should_block_bid(bid_request):
  user_id = bid_request.user.id
  current_timestamp = NOW()

  // Get impression events for this user in the last 2 seconds
  recent_impressions = GET_IMPRESSIONS(user_id, LOOKBACK_WINDOW = 2_SECONDS)

  // If more than 2 impressions were logged at the exact same timestamp, flag user
  IF COUNT_IMPRESSIONS_AT_TIMESTAMP(recent_impressions, current_timestamp) > 2:
    // Add user to a temporary blocklist
    ADD_TO_BLOCKLIST(user_id, DURATION = 1_HOUR)
    LOG_FRAUD("Stacking behavior detected, user blocked.")
    RETURN TRUE // Block bid

  RETURN FALSE

Example 2: Publisher Performance Monitoring

This logic is for an automated system that reviews publisher performance daily. It identifies publishers with an extremely low click-through rate (CTR) despite a high volume of served impressions, which is a strong indicator of impression fraud like ad stacking.

// Daily automated script to review publisher quality

PROCEDURE review_publisher_metrics():
  yesterday_stats = GET_PUBLISHER_STATS(DATE = YESTERDAY)

  FOR publisher in yesterday_stats:
    impressions = publisher.metrics.impressions
    clicks = publisher.metrics.clicks

    // Check for a statistically significant number of impressions
    IF impressions > 50000:
      // Calculate Click-Through Rate
      ctr = clicks / impressions

      // If CTR is abnormally low (e.g., less than 0.01%), pause the publisher
      IF ctr < 0.0001:
        PAUSE_PUBLISHER(publisher.id)
        NOTIFY_ADMIN(f"Publisher {publisher.id} paused due to suspected impression fraud.")

🐍 Python Code Examples

This example simulates checking a log of ad events to find instances where multiple unique ads were recorded for the same user at the exact same timestamp, a clear sign of ad stacking.

import collections

def detect_ad_stacking_by_timestamp(event_logs):
    """
    Analyzes event logs to detect ad stacking based on simultaneous impressions.
    An event log is a list of dicts: {'user_id': 'xyz', 'ad_id': 'abc', 'timestamp': 1677615000}
    """
    events_by_time = collections.defaultdict(list)
    fraudulent_sessions = set()

    # Group ad IDs by user and timestamp
    for event in event_logs:
        key = (event['user_id'], event['timestamp'])
        events_by_time[key].append(event['ad_id'])

    # If any user has multiple unique ad IDs at the same time, flag it
    for (user, timestamp), ad_ids in events_by_time.items():
        if len(set(ad_ids)) > 1:
            fraudulent_sessions.add(user)
            print(f"Ad stacking detected for user {user} at timestamp {timestamp} with ads: {set(ad_ids)}")

    return list(fraudulent_sessions)

# Sample Data
logs = [
    {'user_id': 'user-123', 'ad_id': 'ad-A', 'timestamp': 1677615000},
    {'user_id': 'user-123', 'ad_id': 'ad-B', 'timestamp': 1677615000}, # Fraud
    {'user_id': 'user-123', 'ad_id': 'ad-C', 'timestamp': 1677615000}, # Fraud
    {'user_id': 'user-456', 'ad_id': 'ad-A', 'timestamp': 1677615001},
    {'user_id': 'user-123', 'ad_id': 'ad-A', 'timestamp': 1677615002},
]
detect_ad_stacking_by_timestamp(logs)

This code simulates analyzing publisher data to identify those with an unusually high impression count but an extremely low click-through rate (CTR), which suggests that ads are being served but not seen.

def find_suspicious_publishers(publisher_data):
    """
    Identifies suspicious publishers based on high impressions and very low CTR.
    Publisher data is a list of dicts: {'pub_id': 'pub-01', 'impressions': 50000, 'clicks': 10}
    """
    suspicious_list = []
    IMPRESSION_THRESHOLD = 10000  # Minimum impressions to be considered significant
    CTR_THRESHOLD = 0.0005  # Less than 0.05% CTR

    for pub in publisher_data:
        if pub['impressions'] > IMPRESSION_THRESHOLD:
            ctr = pub['clicks'] / pub['impressions'] if pub['impressions'] > 0 else 0
            if ctr < CTR_THRESHOLD:
                suspicious_list.append(pub['pub_id'])
                print(f"Suspicious publisher found: {pub['pub_id']} (Impressions: {pub['impressions']}, CTR: {ctr:.4f})")
    
    return suspicious_list

# Sample Data
data = [
    {'pub_id': 'pub-good', 'impressions': 75000, 'clicks': 150},
    {'pub_id': 'pub-fraud', 'impressions': 120000, 'clicks': 5}, # Suspicious
    {'pub_id': 'pub-small', 'impressions': 1000, 'clicks': 2},
]
find_suspicious_publishers(data)

Types of Ad stacking

• Classic Layering – This is the most direct form, where multiple ads are placed in the same ad unit using code to layer them. Only the top ad is visible, while others are hidden underneath with their opacity set to zero or near-zero, yet all register an impression.
• Pixel Stuffing – A variation where one or more ads are crammed into a tiny 1x1 pixel iframe. While technically loaded and counted as an impression, the ad is completely invisible to the human eye, making it a severe form of impression fraud.
• Hidden Video Ads – Fraudsters may display a static, visible image to the user while one or more video ads autoplay in the background. The user is unaware of the video content, but the advertiser is charged for a video view, which is often more expensive than a display impression.
• Banner Rotation Abuse – In this method, a single ad placement rapidly rotates through multiple ads in the background, faster than a human could see. Each ad is displayed just long enough to register an impression before being replaced, creating a continuous cycle of fraudulent impressions behind one visible ad space.

🛡️ Common Detection Techniques

• Timestamp Analysis – This technique involves scanning click and impression logs to find multiple ad events from a single user that occur at the exact same time. Since a legitimate user cannot perform multiple actions simultaneously, this is a strong signal of ad stacking.
• Client-Side Ad Geometry Analysis – By using scripts on the webpage, this method checks the coordinates and dimensions of all active ad slots. If multiple ad containers report being fully viewable while occupying the exact same pixel space, it indicates they are stacked.
• Impression and Click-Through Rate (CTR) Monitoring – This involves analyzing publisher performance metrics. A publisher with consistently high impression volumes but an abnormally low or near-zero CTR may be using ad stacking, as the hidden ads cannot be clicked.
• Ad Verification Service – These third-party services deploy sophisticated tags that can inspect the ad environment to determine true viewability. They can identify if an ad is rendered inside a hidden iframe, has zero opacity, or is stacked behind another element.
• Multi-Ad Campaign Correlation – For advertisers running multiple campaigns, this technique involves checking if the same device or user is registering clicks or impressions across different campaigns simultaneously. This pattern is highly indicative of fraudulent activity like ad stacking.

🧰 Popular Tools & Services

Tool	Description	Pros	Cons
TrafficGuard	A comprehensive ad fraud prevention tool that offers real-time detection across multiple channels. It identifies both general and sophisticated invalid traffic (IVT), including bot activity and ad stacking, to protect ad spend.	Real-time prevention, multi-platform support (Google, Facebook, Mobile), granular reporting.	May be more complex for smaller businesses; cost can be a factor for limited budgets.
ClickCease	Focuses on click fraud protection for PPC campaigns on platforms like Google and Facebook Ads. It uses detection algorithms to identify and block fraudulent IPs and devices engaging in invalid clicks.	Specialized for PPC, easy to integrate with major ad platforms, provides detailed click analysis.	Primarily focused on click fraud, may not cover all forms of impression fraud as comprehensively.
HUMAN (formerly White Ops)	An advanced bot detection service that protects against sophisticated automated threats. It verifies the humanity of digital interactions to prevent various types of ad fraud, including ad stacking and bot-driven invalid traffic.	Effective against sophisticated bots, offers pre-bid and post-bid analysis, strong focus on cybersecurity.	Can be an enterprise-level solution, potentially higher cost and complexity.
IAS (Integral Ad Science)	A media measurement and analytics company that provides ad verification services. It helps advertisers ensure their ads are viewable by real people in safe environments and protects against fraud like ad stacking.	Comprehensive verification (viewability, brand safety, fraud), trusted by major brands, provides actionable insights.	Often requires integration with ad servers and DSPs; can be more expensive than single-point solutions.

📊 KPI & Metrics

When deploying ad stacking detection, it's crucial to track metrics that measure both the accuracy of the detection system and its impact on business outcomes. Monitoring these key performance indicators (KPIs) helps ensure that the fraud prevention efforts are effective without inadvertently harming legitimate traffic, thereby maximizing return on investment.

Metric Name	Description	Business Relevance
Fraudulent Impression Rate	The percentage of total impressions flagged as fraudulent due to ad stacking.	Directly measures the scale of the problem and the effectiveness of detection.
False Positive Rate	The percentage of legitimate impressions incorrectly flagged as fraudulent.	A high rate indicates the system is too aggressive, potentially blocking real users and revenue.
Wasted Ad Spend Recovered	The monetary value of impressions and clicks that were identified as fraudulent and blocked or refunded.	Demonstrates the direct financial ROI of the fraud prevention system.
Clean Traffic CTR	The click-through rate calculated after removing all fraudulent impressions from the total count.	Provides a more accurate picture of true campaign performance and user engagement.
Viewable Impression Rate	The percentage of ads that were actually considered viewable according to industry standards.	Helps confirm that budget is being spent on ads that have an opportunity to be seen.

These metrics are typically monitored through real-time dashboards provided by ad fraud detection services or internal analytics platforms. Alerts are often configured to notify teams of sudden spikes in fraudulent activity or abnormal metric fluctuations. This continuous feedback loop is essential for optimizing fraud filters and adjusting detection rules to combat evolving fraud tactics effectively.

🆚 Comparison with Other Detection Methods

Detection Accuracy and Speed

Ad stacking detection often relies on clear technical signals, such as multiple impressions from a single location at the same timestamp or overlapping ad container geometry. This can make its detection highly accurate and fast, suitable for real-time, pre-bid blocking. In contrast, behavioral analytics, which profiles user actions over time, is more effective against sophisticated bots that mimic human behavior but may have a higher latency and be less precise for stopping simple impression fraud like stacking.

Scalability and Resource Intensity

Signature-based detection, which looks for known fraudulent IP addresses or device fingerprints, is highly scalable and computationally cheap. However, it is ineffective against new or unknown fraudsters. Ad stacking detection methods like timestamp correlation are also highly scalable. Behavioral analysis is typically the most resource-intensive, as it requires processing large datasets of user interactions and often relies on complex machine learning models, making it more costly to scale.

Effectiveness Against Different Fraud Types

Ad stacking detection is highly specialized for impression and click fraud where multiple ads are hidden in one slot. It is less effective against other types of fraud like domain spoofing or click injection. Behavioral analytics offers broader protection against invalid traffic generated by bots but might miss simpler schemes like stacking if the traffic source otherwise appears legitimate. CAPTCHAs are effective at separating humans from bots at specific entry points but do not protect against fraud that occurs post-entry, such as an ad being stacked on a legitimate user's session.

⚠️ Limitations & Drawbacks

While effective for its specific purpose, ad stacking detection is not a complete solution for all ad fraud. Its limitations mean it is most effective when used as part of a comprehensive, multi-layered security strategy. Fraudsters continuously evolve their techniques, requiring detection methods to adapt constantly.

• Sophisticated Evasion – Fraudsters can introduce minor, random delays between fraudulent impressions to avoid simultaneous timestamp detection, making the stacking harder to identify with simple rules.
• False Positives – Overly aggressive rules, such as flagging any user with multiple quick impressions, might incorrectly block legitimate users who are rapidly browsing a site, leading to lost revenue opportunities.
• Client-Side Manipulation – Detection methods that rely on client-side scripts can be bypassed if the fraudster can block or alter the script's execution in the user's browser or a compromised environment.
• Limited Scope – Ad stacking detection is specifically designed to catch layered ads. It will not identify other prevalent types of fraud such as domain spoofing, ad injection, or conversion fraud.
• Encrypted Traffic Challenges – Increasing use of encryption can make it harder for network-level tools to inspect traffic and identify the patterns associated with ad stacking without performing complex and resource-intensive decryption.

In scenarios involving highly sophisticated bots or complex fraud schemes, a hybrid approach combining ad stacking detection with behavioral analysis and machine learning is often more suitable.

❓ Frequently Asked Questions

How does ad stacking differ from pixel stuffing?

Ad stacking involves layering multiple full-size ads on top of each other, where only the top one is visible. Pixel stuffing is a more extreme variant where one or more ads are compressed into a single, invisible 1x1 pixel. Both are impression fraud, but pixel stuffing ensures the ad is never seen, while a stacked ad could theoretically be on top.

Can ad stacking occur in mobile apps?

Yes, ad stacking is a very common form of fraud in mobile apps, especially with in-app video ads and banners. Fraudsters can manipulate the ad placements within an app's code to stack multiple ads, leading to advertisers paying for unseen impressions or clicks within the mobile environment.

Is ad stacking always intentional fraud?

While predominantly a fraudulent practice, ad stacking can occasionally happen by accident due to coding errors or misconfigured ad servers on a publisher's site. However, systematic and repeated instances are almost always intentional fraud designed to inflate revenue. Reputable publishers actively monitor their sites to prevent this.

How does detecting ad stacking improve my campaign's ROAS?

By detecting and blocking ad stacking, you stop paying for fake impressions that have zero chance of converting. This directly reduces wasted ad spend. As a result, your budget is allocated only to legitimate, viewable ads, which improves your Return on Ad Spend (ROAS) by ensuring your money is spent on real engagement opportunities.

What is the easiest way to check for ad stacking?

The easiest way for a marketer to spot potential ad stacking is by monitoring campaign metrics. Look for publishers or placements with an unusually high number of impressions but a click-through rate (CTR) that is near zero. Another simple method is to check for multiple clicks or impressions from the same user ID reported at the exact same timestamp in your raw data logs.

🧾 Summary

Ad stacking is a form of digital ad fraud where multiple ads are layered within a single ad placement, with only the top one visible. This technique deceives advertisers into paying for unseen impressions or clicks, leading to wasted ad spend and inaccurate campaign data. Detecting it involves analyzing timestamps and viewability metrics to identify anomalies, which is crucial for protecting budgets and ensuring advertising integrity.

🔗 Related Articles

• What is Ad Stacking and how does it work? - Adjust – https://www.adjust.com/glossary/ad-stacking/
• What is Ad Stacking? [+How to Prevent it] - Edgemesh – https://edgemesh.com/ad-stacking
• What is Ad Stacking? Uncover & Prevent Invisible Ad Fraud - ClickSambo – https://clicksambo.com/ad-stacking/
• Ad Stacking Fraud | Importance, Prevention & Best Practices - Trackier – https://trackier.com/blog/ad-stacking-fraud/
• What is Ad Stacking? - Singular – https://www.singular.net/glossary/ad-stacking/