# Brand Protection: Counterfeit, Fake Shop & Typosquat Detector (`fayoussef/brand-abuse-counterfeit-detector`) Actor

Find fake webshops, counterfeit marketplace listings, typosquatted domains and impersonation profiles abusing your brand. AI classifies every hit, scores the risk, saves a page snapshot as takedown evidence and tells you which report to file. No API key needed.

- **URL**: https://apify.com/fayoussef/brand-abuse-counterfeit-detector.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** AI, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 candidate screeneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Brand Abuse & Counterfeit Detector do?

Brand Abuse & Counterfeit Detector **finds the websites, listings, domains and profiles that are trading on your brand name** and tells you which ones are worth a takedown. Give it your brand and your official domains, and one run sweeps search results, marketplaces, social platforms and lookalike domain space, then uses **AI to classify every hit** as a fake webshop, a counterfeit listing, a typosquatted domain, an impersonation profile, a legitimate retailer or plain noise. Confirmed infringements come back with a **risk score, the evidence behind the verdict, a dated HTML snapshot of the page and the takedown route to use**.

It runs on Apify, so you get a scheduler for weekly sweeps, an API and webhooks to push findings into your own systems, proxy rotation so the sites you are investigating do not block you, and run monitoring with alerts. **No API key is required**: the AI access is built in.

### Why use Brand Abuse & Counterfeit Detector?

Counterfeiting is a trillion-dollar problem and the tooling around it is priced for legal departments, not for the brands actually losing the sales. Commercial brand protection platforms start in the tens of thousands per year and lock the data behind their own dashboards. This Actor does the discovery and triage part for cents per candidate, and hands you a plain dataset.

Use it to:

- **Find fake webshops** built to look like your outlet store, before your customers get burned and blame you.
- **Catch counterfeit marketplace listings** on AliExpress, DHgate, eBay, Etsy, Temu and the rest, with the goods and seller page captured.
- **Monitor typosquatted domains**: misspellings, character swaps, hyphenations, added words and alternative TLDs of your own domain, checked for live DNS.
- **Spot impersonation profiles** posing as your official store on Facebook, Instagram, TikTok, X, Telegram and YouTube.
- **Build a takedown queue** with dated evidence, so registrar complaints, UDRP filings, marketplace notices and platform reports can be filed without re-doing the research.
- **Prove the trend over time**: schedule a weekly sweep and watch whether enforcement is actually reducing the count.

Typical buyers: DTC and ecommerce brands, IP counsel and trademark agencies, marketplace sellers defending a registered brand, and agencies running brand protection as a service.

### How to use Brand Abuse & Counterfeit Detector

1. Click **Try for free** and open the Input tab.
2. Type your **brand name** exactly as shoppers search for it.
3. Add **every domain you own** in Official domains. This keeps your own sites out of the results and gives the lookalike detector its baseline.
4. Pick which **checks** to run. Fake shops and marketplaces are the highest-yield starting point.
5. Click **Start**. Watch the run log, or come back to the Output tab when it finishes.
6. Export the results as JSON, CSV, Excel or HTML, or pull them from the API.
7. Open **Schedules** and set it to run weekly. Brand abuse is a recurring problem, not a one-time audit.

### Input

Only the brand name is required. Everything else has a working default. The full list is on the Input tab; the fields that matter most:

| Field | What it does |
|---|---|
| `brandName` | The trademark to sweep for. |
| `officialDomains` | Domains you own. Excluded from results and used as the typosquat baseline. |
| `checks` | Which abuse types to look for: fake shops, marketplace listings, lookalike domains, social impersonation. |
| `productKeywords` | Product lines counterfeiters copy most, for extra targeted searches. |
| `brandContext` | Free-text notes so the AI can judge borderline cases the way you would. |
| `maxCandidates` | Hard cap on how many candidates get screened. Your main cost control. |
| `minRiskScore` | The AI risk score at which a hit counts as a confirmed infringement. |
| `countryCode` | Which country the searches run from. Sweep each key market separately. |

```json
{
  "brandName": "Ray-Ban",
  "officialDomains": ["ray-ban.com", "rayban.com"],
  "checks": ["fake_shops", "marketplace_listings", "typosquat_domains"],
  "productKeywords": ["Wayfarer", "Aviator"],
  "maxCandidates": 120,
  "minRiskScore": 60,
  "countryCode": "us"
}
```

### Output

One row per screened candidate. Download as JSON, HTML, CSV or Excel, or read it straight from the Apify API.

```json
{
  "brand": "Ray-Ban",
  "url": "https://ray-bn.com/",
  "domain": "ray-bn.com",
  "registrableDomain": "ray-bn.com",
  "discoveredVia": "typosquat",
  "verdict": "typosquat_domain",
  "verdictLabel": "Typosquatted domain",
  "isInfringement": true,
  "riskScore": 90,
  "confidence": "high",
  "reasoning": "A one-character deletion from the official domain, registered and live, redirecting traffic to an unrelated commercial site.",
  "evidenceSignals": ["one-character-deletion", "redirects-off-domain", "no-brand-affiliation"],
  "counterfeitGoods": [],
  "recommendedAction": "File a registrar abuse report and prepare a UDRP complaint for the domain.",
  "ipAddress": "34.111.46.214",
  "httpStatus": 200,
  "evidenceUrl": "https://api.apify.com/v2/key-value-stores/.../records/evidence-ray-bn.com-8c634c7165.html",
  "checkedAt": "2026-07-29T14:07:02+00:00"
}
```

### Data fields

| Field | Description |
|---|---|
| `url` | The page or domain that was screened. |
| `domain` / `registrableDomain` | Hostname, and the domain as a registrar complaint would name it. |
| `discoveredVia` | Which sweep surfaced it: fake\_shop, marketplace, social or typosquat. |
| `verdict` / `verdictLabel` | The AI classification and its plain-English label. |
| `isInfringement` | True when the verdict is brand abuse and the risk score cleared your threshold. |
| `riskScore` | 0 to 100 confidence that this harms the brand. |
| `confidence` | How sure the AI is of its own verdict. |
| `reasoning` | Short explanation citing what was actually on the page. |
| `evidenceSignals` | The specific tells behind the verdict. |
| `pageSignals` | Automated tells found on the page: official claims, deep discounts, missing legal pages, wire-transfer-only payment. |
| `counterfeitGoods` | Products or categories offered under your brand name. |
| `recommendedAction` | The takedown route a brand protection team would use. |
| `evidenceUrl` | Dated HTML snapshot of the page, for confirmed infringements. |
| `ipAddress` | Address a lookalike domain resolves to. |
| `httpStatus` | Status returned when the page was opened. |
| `checkedAt` | UTC timestamp your evidence is stamped with. |

### How much does brand protection monitoring cost?

This Actor charges per event: a small fee for each candidate it screens, and a larger one for each infringement it confirms with evidence. Discovery, DNS checks and de-duplication are free, so a sweep that generates 400 lookalike domains and finds 9 registered ones only ever bills for those 9.

`maxCandidates` is the ceiling on a run's cost. Set it to 120 for a normal weekly sweep, higher for a first full audit of a heavily counterfeited brand.

AI usage is billed separately by Apify's model integration, not by this Actor, so you are never charged twice for the same tokens. The price per million tokens is shown next to every model in the dropdown. If you would rather pay OpenRouter directly, drop your own OpenRouter key into the input and the calls bypass Apify billing entirely.

**Free Plan limits:** free-plan runs screen at most 10 candidates from 4 searches, read 1 page of results per search and generate 30 lookalike domains. That is enough to see the output shape, not enough to protect a brand. [Subscribe to an Apify plan](https://apify.com/pricing?fpr=youssef) to lift the caps. Note that the Free Plan is also charged roughly 10x by the model integration for identical AI usage, so a paid plan cuts that cost too.

### Tips

- **Sweep each market separately.** Counterfeit storefronts are targeted by region. Run one schedule per `countryCode` for your key markets rather than one global sweep.
- **List every domain you own**, including the misspellings you defensively registered. Anything you leave out will come back as a typosquat finding.
- **Use `brandContext` to teach it your market.** Naming your authorized retailers and your real price range cuts false positives more than any other setting.
- **Turn on `onlyInfringements`** once you trust the output, so the dataset is a takedown queue rather than a full audit trail.
- **Lower `minRiskScore` for the first run** to see the grey area, then raise it for the recurring schedule.
- **Leave residential proxy enabled.** Fake shops routinely block datacenter traffic, and a blocked fetch means the AI judges a snippet instead of the page.

### FAQ

**Is monitoring for counterfeits and brand abuse legal?**
Yes. This Actor reads publicly available pages, the same ones any shopper can open. It collects no personal data and does not log in anywhere. Whether a specific page infringes your rights is a legal question for you and your counsel; this Actor gathers the evidence, it does not give legal advice.

**Does the AI verdict replace a lawyer's review?**
No. It is a triage layer that turns thousands of search results into a short, ranked list a human can actually review. Always check the reasoning and the snapshot before filing.

**Do I need an OpenAI or OpenRouter API key?**
No. AI access is built in and needs no key from you. Supplying your own OpenRouter key is optional and only changes who gets billed for the tokens.

**How do I find fake shops using my brand name?**
Enable the fake shops check, add your product lines to `productKeywords`, and run a sweep per market. The Actor searches the phrasings counterfeiters actually use (outlet, clearance, official store, deep discounts) while excluding your own domains.

**How do I check for typosquatted domains?**
Add your domains to `officialDomains` and enable the lookalike domains check. The Actor generates misspellings, doubled and dropped letters, transpositions, keyboard-neighbour typos, homoglyphs, hyphenations, added words like "outlet" or "shop", and alternative TLDs, then keeps only the ones with live DNS.

**Can I run this from an AI agent?**
Yes. Call it from any agent through the Apify MCP server, or from the Apify API. The output schema is published, so an agent can read and chain the results without extra glue.

**Can it file the takedowns for me?**
No. It produces the evidence pack and names the route (registrar abuse report, UDRP, marketplace notice, platform impersonation report). Filing stays with you or your counsel.

**Why did a legitimate retailer show up in my results?**
Because it sells your goods and the sweep found it. It is classified as `authorized_retailer` or `unauthorized_reseller`, not as infringement. Add it to `ignoredDomains` to stop screening it on future runs.

**The run found nothing. What now?**
Widen `checks`, add `productKeywords`, and raise `maxCandidates` and `pagesPerQuery`. If the log shows Google refusing the searches, the run could not reach Apify's Google SERP proxy: that needs Apify Proxy access on your plan, and without it the sweep falls back to a backup engine that returns considerably less.

**Which search engine does it use?**
Google, through Apify's dedicated Google SERP proxy, so the results are the ones your customers actually see. A backup engine sits behind it purely as a safety net for runs that cannot reach the SERP proxy. The run summary reports `searchesBlocked` and `searchesViaBackupEngine` so you always know which one produced your findings. The proxy setting in the input governs how candidate pages are opened and does not affect searching.

### Support

Found a bug or a false positive pattern worth fixing? Open an issue on the **Issues** tab and it gets looked at.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

### Disclaimer

This Actor collects publicly accessible information for brand protection and anti-counterfeiting purposes. It does not access private data, bypass authentication, or interact with the sites it inspects beyond loading a public page. AI classifications are automated judgments and can be wrong: review the reasoning and the saved snapshot before acting on any finding. Nothing here is legal advice.

# Actor input Schema

## `brandName` (type: `string`):

The trademark or brand you want swept for abuse. Use the exact name shoppers search for.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `officialDomains` (type: `array`):

Every domain you legitimately own: your shop, your country sites, your brand microsites. These are excluded from the results and are used as the baseline for lookalike domain detection. Add them without https://.

## `checks` (type: `array`):

Pick the abuse types to sweep for. Each one costs candidates, so start with the first two and widen once you see the results.

## `productKeywords` (type: `array`):

Optional. Model names or product lines counterfeiters copy most, for example Wayfarer or Aviator. Each keyword adds a few targeted searches.

## `brandContext` (type: `string`):

Optional. Anything that helps the AI judge borderline cases: who your authorized retailers are, which regions you sell in, your usual price range, or names that clash with yours.

## `minRiskScore` (type: `integer`):

A hit is only counted and billed as a confirmed infringement at or above this AI risk score. Lower it to catch more, raise it to cut false positives.

## `maxCandidates` (type: `integer`):

Hard cap on how many discovered URLs and domains get AI-screened in one run. This is the main cost control.

## `pagesPerQuery` (type: `integer`):

How deep to read each search. Page 1 holds the sites shoppers actually reach; deeper pages find more but are lower quality.

## `domainVariants` (type: `integer`):

Misspellings, character swaps, hyphenations, added words and alternative TLDs are generated from each official domain, then checked for live DNS. Only registered ones cost anything to screen.

## `countryCode` (type: `string`):

Two-letter country code the searches run from. Counterfeit storefronts are often targeted by region, so sweep your key markets separately.

## `marketplaces` (type: `array`):

Leave empty to use the built-in list of marketplaces where counterfeits concentrate. Add your own to target a specific platform.

## `socialPlatforms` (type: `array`):

Leave empty to use the built-in list. Only used when social media impersonation is enabled.

## `ignoredDomains` (type: `array`):

Domains you never want screened: your authorized retailers, your distributors, press sites you already trust. Major news, encyclopedia and review sites are ignored by default.

## `fetchPages` (type: `boolean`):

Loads the page so the AI judges the real content, not just a search snippet, and so signals like fake official claims and deep discounts are detected. Turn off for a faster, cheaper, shallower sweep.

## `saveEvidence` (type: `boolean`):

Stores the raw HTML of every confirmed infringement in the key-value store, so you have dated proof to attach to a takedown notice.

## `onlyInfringements` (type: `boolean`):

Keeps confirmed infringements and grey-area hits in the dataset and drops the clean ones. Screening is still charged for everything checked.

## `model` (type: `string`):

The model that judges each candidate. A cheap fast model is enough for most sweeps. AI usage is billed separately by Apify's model integration, not by this Actor, and the price per million tokens is shown next to each option.

## `customModel` (type: `string`):

Optional. Overrides the dropdown with any model ID available through the gateway, for example openai/gpt-4.1-mini.

## `openrouterApiKey` (type: `string`):

Optional. Bring your own OpenRouter key and calls go straight to OpenRouter, billed by them on your own OpenRouter account instead of through Apify. Leave empty to use the built-in access, which needs no key at all.

## `concurrency` (type: `integer`):

How many candidates are fetched and classified at once. Higher is faster; lower is gentler on the sites being checked.

## `maxRetries` (type: `integer`):

How many times a failed classification is retried before the candidate is reported as unclassified.

## `proxyConfiguration` (type: `object`):

Proxy used to open candidate pages. Residential exits are recommended: fake shops routinely block datacenter traffic. This setting does not affect searching, which always goes through Apify's dedicated Google SERP proxy.

## `apifyToken` (type: `string`):

Optional. Only needed when running this Actor outside the Apify platform. On the platform it is filled in automatically.

## Actor input object example

```json
{
  "brandName": "Ray-Ban",
  "officialDomains": [
    "ray-ban.com",
    "rayban.com"
  ],
  "checks": [
    "fake_shops",
    "marketplace_listings",
    "typosquat_domains"
  ],
  "productKeywords": [
    "Wayfarer",
    "Aviator"
  ],
  "brandContext": "Sold only through opticians and our own site. Any standalone shop offering 70% off is not authorized.",
  "minRiskScore": 60,
  "maxCandidates": 120,
  "pagesPerQuery": 2,
  "domainVariants": 120,
  "countryCode": "gb",
  "marketplaces": [
    "aliexpress.com",
    "dhgate.com"
  ],
  "socialPlatforms": [
    "facebook.com",
    "instagram.com"
  ],
  "ignoredDomains": [
    "sunglasshut.com"
  ],
  "fetchPages": true,
  "saveEvidence": true,
  "onlyInfringements": false,
  "model": "google/gemini-2.5-flash",
  "concurrency": 8,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `findings` (type: `string`):

One row per screened candidate: verdict, risk score, evidence and recommended takedown route. Switch between the Overview and Takedown queue views in the table.

## `evidence` (type: `string`):

Dated HTML snapshots of every confirmed infringement, ready to attach to a takedown notice.

## `summary` (type: `string`):

Candidates discovered and screened, infringements confirmed, and the verdict breakdown for the sweep.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "brandName": "Ray-Ban",
    "officialDomains": [
        "ray-ban.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/brand-abuse-counterfeit-detector").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "brandName": "Ray-Ban",
    "officialDomains": ["ray-ban.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/brand-abuse-counterfeit-detector").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brandName": "Ray-Ban",
  "officialDomains": [
    "ray-ban.com"
  ]
}' |
apify call fayoussef/brand-abuse-counterfeit-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/brand-abuse-counterfeit-detector",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/JeJZiykrZBVOILzgl/builds/EgkmIOiGuGQVRRqwx/openapi.json