Broadcaster Video on Demand

How Broadcaster Video on Demand Works

  User Request         │        Ad Decision Engine         │       Content & Ad Delivery
┌──────────────────┐   │   ┌─────────────────────────────┐   │   ┌────────────────────────┐
│ User selects     ├───────►│ 1. Authenticate User        ├───────►│ Stream Content + Ad    │
│ content on       │   │   │    (Device ID, User Agent)  │   │   │ to authenticated user  │
│ BVOD platform    │   │   └─────────────────────────────┘   │   └────────────────────────┘
└──────────────────┘   │                  │                  │
                       │                  ▼                  │
                       │   ┌─────────────────────────────┐   │
                       │   │ 2. Analyze Request          ├─┐ │
                       │   │    (IP, Geo, Time)          │ │ │
                       │   └─────────────────────────────┘ │ │
                       │                  │                │ │
                       │                  ▼                │ │
                       │   ┌─────────────────────────────┐ │ │
                       │   │ 3. Check against Fraud Rules│ │ │
                       │   │    (e.g., blocklists,       │ │ │
                       │   │     frequency caps)         │ │ │
                       │   └─────────────────────────────┘ │ │
                       │                  │                │ │
                       │                  ▼                │ │
                       │   ┌─────────────────────────────┐ │ │
                       │   │ 4. Final Verdict:           ├─┘ │
                       │   │    Allow or Block           │   │
                       │   └─────────────────────────────┘   │

🧠 Core Detection Logic

Example 1: IP Blocklisting

This logic prevents traffic from known fraudulent sources. When a request comes in, its IP address is checked against a database of addresses associated with data centers, VPNs, or past fraudulent activity. This is a first line of defense in a traffic protection system.

function isFraudulent(request) {
  const ip = request.getIp();
  if (isKnownDataCenter(ip) || isBlacklisted(ip)) {
    return true; // Block request
  }
  return false;
}

Example 2: Session Heuristics

This logic analyzes user behavior within a single session to spot anomalies. It looks at the time between clicks, page interaction, and navigation flow. Unusually fast clicks or a lack of typical user engagement can indicate a bot. This fits within the behavioral analysis layer of traffic protection.

function analyzeSession(session) {
  const clickTimes = session.getClickTimestamps();
  if (clickTimes.length > 1) {
    const timeDiff = clickTimes - clickTimes;
    if (timeDiff < 200) { // Less than 200ms
      return "suspicious";
    }
  }
  return "legitimate";
}

Example 3: Geo Mismatch Detection

This logic compares the geographical location of the IP address with other user data, such as their stated region or timezone settings. A significant mismatch can suggest the use of a proxy or a compromised device. This is often used to enforce content licensing and detect sophisticated fraud.

function checkGeoMismatch(request) {
  const ipGeo = getGeoFromIp(request.getIp());
  const userProfileGeo = request.getUserProfile().getCountry();
  if (ipGeo !== userProfileGeo) {
    logSuspiciousActivity("Geo Mismatch", request);
    return true;
  }
  return false;
}

📈 Practical Use Cases for Businesses

Businesses use Broadcaster Video on Demand to ensure their advertising budget is spent on real, engaged viewers. It provides a brand-safe environment with professionally produced content, which enhances campaign effectiveness. By leveraging the detailed viewership data from BVOD platforms, companies can refine their targeting and improve their return on ad spend, knowing that their ads are being seen by genuine customers in a trusted setting.

• Campaign Shielding – Protects ad campaigns from invalid traffic and bots by running them in a closed, monitored environment, maximizing budget efficiency.
• Clean Analytics – Ensures marketing analytics are based on real human interactions, leading to more accurate insights and better strategic decisions.
• Improved ROI – Increases return on investment by placing ads in premium, brand-safe content where viewers are more engaged and receptive to advertising.
• Audience Verification – Guarantees that ads are served to the intended demographic by using the broadcasters' first-party data for precise audience targeting.

Example 1: Geofencing Rule

function applyGeofencing(user) {
  const allowedCountries = ["US", "CA", "GB"];
  const userCountry = getCountryFromIP(user.ip_address);

  if (!allowedCountries.includes(userCountry)) {
    blockAdRequest(user.id);
    logEvent("Blocked", "Geo-fence", user.ip_address);
  } else {
    serveAd(user.id);
  }
}

Example 2: Session Scoring Logic

function scoreSession(session) {
  let score = 0;
  // High engagement (e.g., video completion) is a good sign
  if (session.videoCompletion > 0.9) {
    score += 10;
  }
  // Multiple rapid-fire ad clicks are a bad sign
  if (session.adClicks > 3 && session.duration < 60) {
    score -= 20;
  }
  return score;
}

🐍 Python Code Examples

This Python code filters incoming web traffic by checking if the IP address is in a known blocklist of fraudulent actors. This is a common first step in any ad fraud detection system to weed out obviously bad traffic before it consumes resources.

def filter_blocked_ips(ip_address, blocklist):
    """
    Checks if an IP address is in the blocklist.
    """
    if ip_address in blocklist:
        print(f"Blocking fraudulent IP: {ip_address}")
        return True
    return False

# Example Usage
fraudulent_ips = {"1.2.3.4", "5.6.7.8"}
incoming_ip = "1.2.3.4"
filter_blocked_ips(incoming_ip, fraudulent_ips)

The following code analyzes the frequency of clicks from a single user to identify behavior that is too fast to be human. This helps in detecting automated bots that are programmed to click on ads at an inhuman rate.

import time

def detect_abnormal_click_frequency(user_session):
    """
    Detects if clicks are happening too quickly.
    """
    click_timestamps = user_session.get("clicks", [])
    if len(click_timestamps) < 2:
        return False

    time_diff = click_timestamps[-1] - click_timestamps[-2]
    if time_diff < 0.5:  # Less than 500 milliseconds
        print("Abnormal click frequency detected!")
        return True
    return False

# Example Usage
session = {"user_id": "user-123", "clicks": [time.time()]}
time.sleep(0.2)
session["clicks"].append(time.time())
detect_abnormal_click_frequency(session)

This example scores traffic based on the user agent string provided by the browser. Suspicious user agents, such as those that are outdated or known to be used by bots, receive a lower score, helping to filter out non-human traffic.

def score_traffic_by_user_agent(user_agent):
    """
    Scores traffic based on the user agent string.
    """
    score = 100
    if not user_agent or "bot" in user_agent.lower():
        score = 0
    elif "headless" in user_agent.lower():
        score = 10
    
    print(f"User agent '{user_agent}' scored: {score}")
    return score

# Example Usage
suspicious_ua = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
score_traffic_by_user_agent(suspicious_ua)

Types of Broadcaster Video on Demand

• Server-Side Ad Insertion (SSAI) – This type stitches ads directly into the video stream on the server side before it reaches the user's device. This makes the ads difficult for ad-blockers to detect and remove, ensuring a seamless viewing experience and protecting ad revenue from being lost.
• Client-Side Ad Insertion (CSAI) – In this method, the video player on the user's device requests ads from an ad server separately from the content. While more susceptible to ad blockers, it allows for more personalized and targeted advertising based on data available on the client side.
• Hybrid Models – This approach combines elements of both SSAI and CSAI. For instance, some ads might be stitched into the stream server-side for all viewers, while other ad slots are filled client-side to allow for dynamic, targeted advertising. This provides a balance between robust ad delivery and personalization.
• Authenticated Viewing – This type requires users to log in before accessing content. This provides valuable first-party data, allowing for highly targeted advertising and a much lower risk of fraud, as user accounts can be monitored for suspicious activity over time.