Mass App-Ads Checker

Note

This project has been merged into OstinUA/Mass-Ads-App-Ads-Checker and refactored to support a new configuration. Future development and updates will continue in the new repository.

---

A Chrome Extension for high-volume app-ads.txt validation with deterministic URL probing, IAB line parsing, and export-ready reporting for AdOps workflows.

Related Projects

This tool is part of the AdTech Automation Suite. Check out the companion extension:

Project	Type	Description
Mass-App-Ads-Checker	Chrome Extension	Mass App-Ads.txt Checker is a Chrome Extension for high-volume app-ads.txt validation file
Mass-Ads-Checker	Chrome Extension	Mass Ads.txt Checker is a Chrome Extension for high-volume ads.txt validation file

Important

This project is implemented as a Chrome Extension (Manifest V3), not a server-side scanner. Requests are executed from the browser runtime to improve parity with real user traffic patterns.

Table of Contents

• Features
• Tech Stack \& Architecture
  • Core Technologies
  • Project Structure
  • Key Design Decisions
• Getting Started
  • Prerequisites
  • Installation
• Testing
• Deployment
• Usage
• Configuration
• License
• Support the Project

Features

• Bulk processing of domain lists entered as newline-separated input.
• Smart URL probing strategy with protocol and subdomain fallbacks:
  • https://www.<domain>/app-ads.txt
  • https://<domain>/app-ads.txt
  • http://www.<domain>/app-ads.txt
  • http://<domain>/app-ads.txt
• Runtime request timeout protection (AbortController) to avoid UI deadlocks on slow hosts.
• Heuristic HTML response rejection to filter false positives (e.g., HTML error pages served with 200).
• IAB-oriented record validation that counts only lines containing valid relationship types:
  • DIRECT
  • RESELLER
• Comment-safe parsing (# support) and UTF BOM normalization.
• Real-time progress tracking (completed/total) in the UI status bar.
• Result classification with user-friendly statuses:
  • Valid
  • Empty File
  • Error
• Export to CSV for spreadsheet pipelines (Excel / Google Sheets).
• Dedicated popup window launch flow via service worker click action.
• Lightweight footprint: no build step, no npm runtime dependency, static extension assets only.

Tip

For large batches, paste clean root domains only (one per line). The checker already normalizes protocol and www prefixes before probing.

Tech Stack & Architecture

Core Technologies

• JavaScript (Vanilla) for runtime logic and parsing.
• HTML + CSS for extension UI.
• Chrome Extension APIs (Manifest V3):
  • chrome.action for launch handling.
  • chrome.windows.create for popup window mode.
• Browser Fetch API for outbound app-ads.txt retrieval.

Project Structure

Mass-App-Ads-Checker/
├── LICENSE
├── README.md
├── manifest.json         # Extension manifest and permissions
├── background.js         # Action click handler and popup window creation
├── popup.html            # UI layout and embedded styles
├── popup.js              # Input processing, fetch pipeline, parsing, CSV export
└── icons/
    └── icon128app.png    # Extension icon

Key Design Decisions

1. Browser-executed checks instead of backend scans

   • Running checks in the Chrome context can reduce mismatch with browser-facing protections encountered by headless scripts.

2. Deterministic fallback URL order

   • The probing sequence prioritizes HTTPS and www first, then progressively relaxes constraints.

3. Conservative “valid line” logic

   • Only structurally parseable records with DIRECT or RESELLER are counted, reducing noise from malformed files.

4. Operational safety through bounded waiting

   • Per-request timeout limits long-tail host latency impact on batch throughput.

flowchart TD
    A[User pastes domains] --> B[Normalize domain string]
    B --> C[Build candidate URLs]
    C --> D[Fetch with timeout]
    D -->|HTTP 200 + non-HTML| E[Parse app-ads.txt]
    E --> F[Count DIRECT/RESELLER lines]
    F --> G[Render table row]
    D -->|Failure / invalid payload| H[Try next URL]
    H --> D
    G --> I[Accumulate results]
    I --> J[CSV Export]

Loading

Note

The extension currently processes domains in small concurrent batches to balance responsiveness and request fan-out.

Getting Started

Prerequisites

• Google Chrome (recent stable channel).
• A local clone of this repository.
• No Node.js/Python toolchain is required for baseline usage.

Installation

git clone https://github.com/<your-org>/Mass-App-Ads-Checker.git
cd Mass-App-Ads-Checker

1. Open chrome://extensions/.
2. Enable Developer mode.
3. Click Load unpacked.
4. Select the Mass-App-Ads-Checker project folder.
5. Click the extension icon to launch the checker window.

Warning

The extension requests broad host permissions (http://*/*, https://*/*) to query arbitrary publisher domains. Review manifest.json before deployment in managed environments.

Testing

This repository does not currently include an automated test harness. Recommended validation commands and checks:

# Validate extension manifest structure
python -m json.tool manifest.json > /dev/null

# Basic JavaScript syntax validation (Node.js optional)
node --check background.js
node --check popup.js

Manual verification checklist:

1. Load extension in Chrome without manifest errors.
2. Run a known-valid domain and verify Valid with non-zero line count.
3. Run a domain with no app-ads.txt and verify Error fallback behavior.
4. Download CSV and verify column integrity: App-Ads URL,Status,Lines.

Caution

Cross-origin behavior may vary by target site controls, TLS posture, and transient network conditions. Always validate a sample repeatedly before making policy decisions.

Deployment

Production Usage Model

• Deploy as an unpacked extension for internal teams, or package for controlled distribution.
• For enterprise rollout, publish via Chrome Web Store (private/unlisted/public depending on policy).

Packaging

1. Open chrome://extensions/.
2. Use Pack extension.
3. Select repository root as extension directory.
4. Distribute generated .crx and private key according to your trust model.

CI/CD Integration (Suggested)

• Add a pipeline stage to:
  • Validate manifest.json syntax.
  • Run JavaScript syntax checks.
  • Optionally lint JS/HTML with your preferred tooling.
• Tag releases using semantic versioning and keep manifest.json version synchronized.

Usage

1. Click the extension icon to open the checker window.
2. Paste domains (one per line) into the textarea.
3. Click Run Check.
4. Review per-domain URL, status, and valid-line count.
5. Click Download CSV for offline analysis.

Parsing Logic Example

// Example: count valid app-ads records from file content
function countValidLines(content) {
  let count = 0;
  const cleanContent = content.replace(/\uFEFF/g, '');
  const lines = cleanContent.split(/\r?\n/);

  for (const line of lines) {
    const clean = line.split('#')[0].trim();
    if (!clean) continue;

    const parts = clean.split(',').map((p) => p.trim());
    if (parts.length >= 3) {
      const type = parts[2].toUpperCase().replace(/[^A-Z]/g, '');
      if (type === 'DIRECT' || type === 'RESELLER') {
        count++;
      }
    }
  }

  return count;
}

Expected CSV Schema

App-Ads URL,Status,Lines
https://www.example.com/app-ads.txt,Valid,17
https://www.sample.org/app-ads.txt,Empty File,0
example.net,Error,0

Configuration

Extension Manifest Configuration

• manifest_version: 3
• name: Mass App-Ads Checker
• version: current extension version (2.0)
• permissions: storage
• host_permissions: http://*/*, https://*/*
• background.service_worker: background.js

Runtime Behavior Configuration (Code-Level)

The following values are currently hard-coded in popup.js and can be externalized if needed:

• batchSize = 2 for domain concurrency.
• Request timeout of 20000 ms per URL attempt.
• URL probing order (HTTPS/HTTP with and without www).
• Status mapping logic (Valid, Empty File, Error).

Environment Variables

• No .env variables are required at this time.
• If integrating into a larger toolchain, prefer build-time substitution or managed config generation for manifest/runtime constants.

License

This project is licensed under the MIT License. See LICENSE for full terms.

Support the Project

If you find this tool useful, consider leaving a star on GitHub or supporting the author directly.