Cloaking Detector

Detect SEO cloaking by comparing content served to different user agents.

What does Cloaking Detector do?

This actor detects SEO cloaking by fetching pages with three different user agents (Chrome, Googlebot, Bingbot) and comparing the responses. It checks for differences in title, meta description, body text length, link counts, and status codes. Returns a similarity score and flags potential cloaking.

Cloaking is a violation of Google's webmaster guidelines where a site serves different content to search engine crawlers than to regular users. This actor automates the detection process by comparing all three versions of each page side by side, highlighting any discrepancies that could indicate intentional or accidental cloaking.

The comparison covers multiple dimensions of the page including the title tag, meta description, visible text length, link count, and HTTP status code. Each dimension is checked independently, so you can see exactly which aspects of the page differ between user agents. Results include a similarity score from 0 to 100 and a detailed list of all detected differences.

Use cases

• SEO auditor -- run cloaking checks across a client's entire site to verify compliance with search engine guidelines
• Competitor analyst -- investigate whether competitor sites are using deceptive cloaking to gain unfair ranking advantages
• Website owner -- verify that your CDN, caching layer, or A/B testing tool is not accidentally serving different content to bots
• Compliance officer -- ensure advertising landing pages show the same content to both users and search engine crawlers to meet ad platform policies
• Security researcher -- detect malicious cloaking where hacked sites redirect search engine traffic to spam pages
• Digital marketing manager -- verify that landing pages built by external agencies do not use cloaking techniques that could lead to search engine penalties
• Affiliate manager -- check that affiliate landing pages serve identical content to users and search engine bots to avoid policy violations

Why use Cloaking Detector?

• Three user agents in one run -- compares Chrome, Googlebot, and Bingbot responses automatically
• Detailed difference reporting -- pinpoints exactly which elements differ: title, meta description, text length, links, or status code
• Similarity score -- each page gets a 0-100 score so you can prioritize the worst offenders
• Batch processing -- check hundreds of URLs in a single run
• Structured JSON output -- results are ready for spreadsheets, dashboards, or further processing
• Pay-per-event pricing -- only pay for the URLs you check
• No setup required -- just provide a list of URLs and the actor handles all user agent switching and comparison logic automatically

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	List of URLs to check for cloaking. Each URL is fetched three times with different user agents.

Input example

{
    "urls": [
        "https://www.google.com",
        "https://www.wikipedia.org",
        "https://example.com"
    ]
}

Output example

{
    "url": "https://example.com",
    "cloakingDetected": false,
    "similarityScore": 100,
    "titleMatch": true,
    "metaDescriptionMatch": true,
    "statusCodeMatch": true,
    "textLengthDifference": 0,
    "linkCountDifference": 0,
    "differences": [],
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Event	Price	Description
Start	$0.035	One-time per run
URL checked	$0.003	Per URL checked (3 requests per URL)

Example costs:

• 10 URLs: $0.035 + (10 x $0.003) = $0.065
• 100 URLs: $0.035 + (100 x $0.003) = $0.335
• 1,000 URLs: $0.035 + (1,000 x $0.003) = $3.035

Using the Apify API

You can call Cloaking Detector programmatically from your own applications using the Apify API. The following examples show how to start a run, wait for it to finish, and retrieve the results.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/cloaking-detector').call({
    urls: ['https://example.com'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('automation-lab/cloaking-detector').call(run_input={
    'urls': ['https://example.com'],
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Cloaking Detector works with all major automation and integration platforms available on Apify. Connect it to Make (formerly Integromat) or Zapier to trigger alerts when cloaking is detected on any monitored page. Send results to Google Sheets for easy reporting and sharing with stakeholders. Push notifications to Slack when a page's similarity score drops below a threshold. Use webhooks to receive instant callbacks when a run finishes, or build advanced pipelines with n8n. You can also schedule recurring runs on Apify to continuously monitor your site for accidental cloaking. All results are stored in Apify datasets and can be downloaded in JSON, CSV, or Excel format for further analysis.

Tips and best practices

• Check after deploying changes -- caching layers, CDNs, and server-side rendering can accidentally introduce cloaking
• Monitor A/B testing pages -- if your A/B tool shows different variants to bots vs. users, Google may flag it as cloaking
• Focus on pages with low similarity scores -- a score below 90 indicates significant differences worth investigating
• Run periodically on high-value pages -- schedule weekly checks on your top landing pages and money pages
• Combine with other SEO checks -- pair cloaking detection with canonical and title checks for a comprehensive audit
• Test after adding JavaScript-based content -- content loaded via JavaScript may not appear when fetched as Googlebot if server-side rendering is not configured

FAQ

What exactly is cloaking? Cloaking is the practice of serving different content to search engine crawlers than to regular users. It violates Google's guidelines and can result in a manual penalty or complete deindexing. Common examples include showing keyword-stuffed text to bots or redirecting users to different pages.

Why does each URL cost $0.003 instead of $0.001? Each URL is fetched three times -- once as Chrome (regular user), once as Googlebot, and once as Bingbot. The three responses are then compared to detect differences. This costs roughly three times more than a single-fetch check.

Can accidental cloaking happen? Yes. Server-side rendering, caching layers, geo-targeting, A/B testing tools, and JavaScript-dependent content can all cause unintentional differences between what bots and users see. This actor helps catch those cases.

What similarity score indicates cloaking? A score of 100 means all three user agent responses are identical. Scores between 90 and 100 usually indicate minor, harmless differences (e.g., slightly different ad content). Scores below 90 warrant investigation, and scores below 50 strongly suggest intentional or severe accidental cloaking.

Does the actor detect JavaScript-rendered content differences? The actor compares the raw HTML responses served to each user agent. It does not execute JavaScript. This means it detects server-side cloaking (different HTML served) but not differences that only appear after JavaScript execution in a browser.

How often should I run cloaking checks? For most sites, running cloaking checks weekly or after every deployment is sufficient. If you use A/B testing or dynamic content, consider running checks more frequently on the pages affected by those systems. Schedule automated runs on Apify for hands-free monitoring.

How many URLs can I check in one run? There is no hard limit. You can submit hundreds or thousands of URLs in a single run. Keep in mind that each URL generates three HTTP requests, so large batches take proportionally longer to complete.