Ad inventory

How Ad inventory Works

Incoming Ad Request
       │
       ▼
+---------------------+
│ 1. Inventory Source │
│   (Publisher URL)   │
+---------------------+
       │
       ▼
+---------------------+
│ 2. Verification     │
│  (e.g., ads.txt)    │
+---------------------+
       ├─ Legitimate ─────► Deliver Ad
       │
       └─ Fraudulent
            │
            ▼
+---------------------+
│ 3. Fraud Detection  │
│  (Pattern Analysis) │
+---------------------+
       │
       ▼
+---------------------+
│ 4. Block & Report   │
+---------------------+
  

🧠 Core Detection Logic

Example 1: Domain Spoofing Detection via ads.txt

This logic verifies if the seller of the ad space is authorized by the publisher. It prevents a common fraud type where a low-quality site pretends to be a premium publisher to command higher ad prices. It’s a foundational check in programmatic advertising.

FUNCTION check_seller_authorization(bid_request):
  publisher_domain = bid_request.get_domain()
  seller_id = bid_request.get_seller_id()

  // Fetch the publisher's authorized seller list
  authorized_sellers = fetch_ads_txt(publisher_domain)

  IF seller_id IS IN authorized_sellers:
    RETURN "Authorized"
  ELSE:
    RETURN "Unauthorized - Potential Spoofing"
END FUNCTION

Example 2: Click Farm Identification via IP Analysis

This logic identifies multiple clicks originating from a single source within a short time frame, a hallmark of click farms or bot activity. It helps block traffic that is not genuinely interested in the ad content, thereby protecting the advertiser’s budget from being wasted.

// Session data store (key: IP address, value: list of click timestamps)
IP_CLICK_LOGS = {}

FUNCTION is_click_farm_activity(click_event):
  ip = click_event.get_ip_address()
  timestamp = click_event.get_timestamp()
  
  // Initialize log for new IP
  IF ip NOT IN IP_CLICK_LOGS:
    IP_CLICK_LOGS[ip] = []

  // Add current click timestamp
  IP_CLICK_LOGS[ip].append(timestamp)

  // Check for excessive clicks in the last minute
  clicks_in_last_minute = count_clicks_since(IP_CLICK_LOGS[ip], now() - 60 seconds)

  IF clicks_in_last_minute > 20:
    RETURN TRUE // Flag as fraudulent
  ELSE:
    RETURN FALSE
END FUNCTION

Example 3: Session Heuristics for Bot Detection

This logic analyzes user behavior within a session to differentiate humans from bots. Bots often exhibit non-human patterns like instantaneous clicks after a page load or no mouse movement. This check helps invalidate traffic that lacks genuine user engagement.

FUNCTION analyze_session_behavior(session_data):
  time_on_page = session_data.get_time_on_page()
  has_mouse_movement = session_data.has_mouse_events()
  time_to_click = session_data.get_time_to_first_click()

  // Rule 1: A real user spends some time on the page before clicking
  IF time_to_click < 1 second:
    RETURN "Fraudulent: Click too fast"
  
  // Rule 2: A real user typically moves the mouse
  IF time_on_page > 3 seconds AND NOT has_mouse_movement:
    RETURN "Fraudulent: No mouse activity"
  
  RETURN "Legitimate"
END FUNCTION

📈 Practical Use Cases for Businesses

Example 1: Geolocation Mismatch Rule

This logic prevents fraud where traffic is masked to appear from a high-value country. A business running a US-only campaign would use this to reject clicks from inventory where the user’s IP address doesn’t match the expected geographical location.

// Rule to check if the click's IP location matches the campaign's target country

FUNCTION validate_geolocation(click_ip, campaign_target_country):
  user_country = get_country_from_ip(click_ip)
  
  IF user_country != campaign_target_country:
    // Mismatch detected, flag as invalid
    REJECT_CLICK(reason="Geolocation mismatch")
    log_event("Fraud Warning: IP country does not match campaign target.")
    RETURN FALSE
  ELSE:
    // Geolocation is valid
    ACCEPT_CLICK()
    RETURN TRUE
END FUNCTION

Example 2: Ad Stacking Detection

This logic detects if an ad impression is fraudulent because the ad is hidden or “stacked” beneath other ads, making it invisible to the user. Businesses use this to ensure they only pay for viewable impressions, protecting their budget from being wasted on unseen ads.

// Logic to check the visibility of an ad element on a page

FUNCTION check_ad_visibility(ad_element_id):
  ad = get_element_by_id(ad_element_id)
  
  // Check if the ad is hidden via CSS
  IF ad.style.visibility == "hidden" OR ad.style.display == "none":
    RETURN "Fraudulent: Ad is hidden"
  
  // Check if the ad's dimensions are impossibly small (pixel stuffing)
  IF ad.width < 2 AND ad.height < 2:
    RETURN "Fraudulent: Pixel stuffing detected"

  // Check if the ad is obscured by another element on top
  element_at_ad_center = get_element_at_coordinates(ad.center_x, ad.center_y)
  IF element_at_ad_center != ad:
    RETURN "Fraudulent: Ad is stacked or obscured"
    
  RETURN "Legitimate"
END FUNCTION

🐍 Python Code Examples

This code filters incoming ad clicks based on a predefined list of high-risk IP addresses known for fraudulent activity. It is a direct and effective method to block obvious bot traffic and protect advertising campaigns from repeated offenders.

# A predefined set of known fraudulent IP addresses
FRAUDULENT_IPS = {"198.51.100.1", "203.0.113.10", "192.0.2.55"}

def filter_by_ip_blocklist(click_ip):
    """
    Checks if a click's IP is in a known fraudulent IP blocklist.
    """
    if click_ip in FRAUDULENT_IPS:
        print(f"Blocking fraudulent click from IP: {click_ip}")
        return False  # Invalid click
    print(f"Accepting legitimate click from IP: {click_ip}")
    return True  # Valid click

# --- Simulation ---
filter_by_ip_blocklist("198.51.100.1")  # Returns False
filter_by_ip_blocklist("8.8.8.8")        # Returns True

This example demonstrates how to detect abnormally high click frequency from a single user agent, which can indicate automated bot activity. By tracking the number of clicks over a short time window, this function can flag non-human behavior designed to exhaust ad budgets.

from collections import defaultdict
import time

# In a real system, this would be a more persistent store like Redis
CLICK_TIMESTAMPS = defaultdict(list)
TIME_WINDOW_SECONDS = 60
CLICK_LIMIT = 15

def is_abnormal_frequency(user_agent):
    """
    Detects if a user agent has an unusually high click frequency.
    """
    current_time = time.time()
    
    # Get timestamps for this user agent
    timestamps = CLICK_TIMESTAMPS[user_agent]
    
    # Filter out old timestamps that are outside the time window
    recent_timestamps = [t for t in timestamps if current_time - t < TIME_WINDOW_SECONDS]
    
    # Add the current click's timestamp
    recent_timestamps.append(current_time)
    CLICK_TIMESTAMPS[user_agent] = recent_timestamps
    
    # Check if the click count exceeds the limit
    if len(recent_timestamps) > CLICK_LIMIT:
        print(f"Fraud Warning: High click frequency from User-Agent: {user_agent}")
        return True # Abnormal frequency detected
    return False # Normal frequency

# --- Simulation ---
ua_bot = "Mozilla/5.0 (compatible; MyBot/1.0)"
for _ in range(20):
    is_abnormal_frequency(ua_bot)

Types of Ad inventory