# Website Similarity: Compare Your Site With Others (`locaihost/website-similarity`) Actor

Compare your site against sites you choose: copied wording, copied design, same template. Scores copied sentences, page layout, look, code and shared files, with plain-English reasons and a side-by-side picture. You list the sites; nothing is searched. No login. Pay only for the sites compared.

- **URL**: https://apify.com/locaihost/website-similarity.md
- **Developed by:** [locaihost data](https://apify.com/locaihost) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $66.00 / 1,000 website checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Website Similarity: compare your site against sites you choose

Compare your site against sites you choose: copied wording, copied design, same template. Give it your website and the addresses you want it compared with. It opens each one, scores how alike it is, and tells you why: **copied wording, page layout, look, custom code, shared image files**, and whether the match is just the same off-the-shelf template. Each result comes with plain-English reasons, your copied sentences, a side-by-side picture and a PDF you can keep. No login. It reads only the sites you list, and only the pages their robots.txt allows.

### Quick start

Add your site under **Your websites** and the sites to compare under **Compare against these sites**, then press Start.

```json
{
  "startUrls": ["https://www.yourcompany.com"],
  "compareWith": ["https://competitor-one.example", "https://competitor-two.example"],
  "checks": ["content", "design"]
}
```

`compareWith` is required: the Actor does not search for sites, it compares your site with the ones you name. Every site you list is scored and returned, even when the score is low.

### What you get

One row per site you listed, best match first:

| Field | Meaning |
|---|---|
| `similarityScore` | 0 to 100. 70 and up is a clear copy. 40 to 70 is a look-alike or a shared template |
| `verdict` | `copied-content`, `copied-design`, `same-template`, `lookalike` |
| `reasons` | Plain English, strongest first: "7 of your 10 sentences word for word", "Same page layout (88%)", "Uses 3 of your image files", "Both use the Astra theme: likely a template, not a copy" |
| `copiedSentences` | Up to 5 of your own sentences found word for word on their site |
| `contentOverlap`, `topicSimilarity` | Share of your 5-word phrases on their pages, and how alike the subject matter is |
| `layoutSimilarity`, `visualSimilarity`, `paletteSimilarity` | Where the blocks sit, how the first three screens look, how alike the colours are |
| `sharedFiles`, `sharedClasses`, `sharedFonts` | Identical image or style files (including your files loaded straight from your server), custom CSS names both pages use, shared fonts |
| `templates` | Theme or site builder detected on each site |
| `archive` | When the Internet Archive first saved each page, and which was earlier (copy verdicts) |
| `comparisonImageUrl`, `reportUrl` | A side-by-side picture and a PDF evidence report, for scores of 60 or more |
| `foundVia` | Always `your-list` (the sites you named) |

The run summary (key `SUMMARY`) lists websites checked, sites compared, what could not be read, and the cost.

### How it decides

- **Copied content.** It takes distinctive sentences from your pages, reads the pages of each site you listed, and counts your sentences and 5-word phrases on them.
- **Copied design.** It opens both pages in a browser and compares what each block on the first three screens is (heading, text, image, button, card) and where it sits, the look of the screen, the colours, the custom CSS class names, and byte-for-byte identical image and style files. Class names that many unrelated sites use (page builders, plugins, frameworks) are ignored, so two sites on the same builder are not called copies of each other.
- **Same template.** Two sites on the same theme (for example the same WordPress or Shopify theme) look alike by design. These are labelled `same-template` and are not called copies unless they also share files or custom code.
- **Look-alikes.** Sites with a close layout or the same subject matter.

On our own test set of unrelated small-business sites, 99% of pairs score below 25. Plain clones, new-wording copies of a design, and re-skinned copies of the wording all score 70 or more. The score is an estimate: read the reasons and the picture before you act.

### Pricing

Pay per event, no subscription:

- **Website checked**: $0.12 per website you ask about (cheaper on higher Apify plans). It covers reading your site and comparing it with the sites you list. A website that cannot be read is free.
- **Similar site**: $0.02 per compared site returned. Repeats in monitor mode and unreadable sites are free.

A typical check against 2 listed sites costs about $0.16. The run summary shows what the run cost us to execute, for transparency.

### Watch for new copies

Turn on **Only new matches since the last run** and schedule the Actor weekly. It remembers what it already told you (in a named store in your account) and returns only new matches or ones whose score rose by 15 points or more. Rows carry `change: "new"` or `"rising"`.

### Options

| Input | What it does |
|---|---|
| `startUrls` | Up to 50 of your websites to check (the older name `websites` still works) |
| `compareWith` | Up to 100 sites to compare them with. Required |
| `checks` | `content`, `design`, or both. Design opens each page in a browser, so it takes longer |
| `minScore` | Used for the summary report's look-alike count. Every site you list is returned with its score |
| `pagesPerSite` | Pages read on your site (home plus linked pages), 1 to 10 |
| `onlyNew`, `watchName` | Monitor mode and the name of its memory |
| `saveImages`, `makeReports` | Side-by-side pictures and PDF reports |

Inputs from earlier versions (`findSimilar`, `maxCandidates`, `country`) are accepted and ignored. If `findSimilar` is on, the run says so in its status message.

### Limits, stated plainly

- **It does not search the web.** It compares your site with the sites you name. To find who copied you, you need the addresses first.
- **Sites that block automated visits** (bot checks, a refusal such as HTTP 403 or 429) are reported as unreadable and left alone. The Actor does not retry them from another address and does not use a proxy. Unreadable sites you listed are returned without a charge.
- **robots.txt is respected.** Pages a site does not allow are not read. Requests to one site are made one after another.
- **Free plan:** up to 3 websites per run and 5 compared sites per website. Any paid Apify plan removes both limits.
- Scores for look-alikes are less certain than for copies. Use them to find competitors, not as proof.

### Responsible use

Use it on business websites. It reads public pages only, never logs in, and never tries to find out who owns a site. Results are automated estimates, not legal advice. If you plan to send a takedown request, keep the PDF report and check the evidence yourself first.

# Changelog

This Actor's version history is a separate document: https://apify.com/locaihost/website-similarity/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Your site, or any site you want to compare against others. One address per line, up to 50. Each is read (home page and up to three linked pages), then compared with the sites you list below.

## `compareWith` (type: `array`):

Required. The sites to compare your websites with, one address per line, up to 100. Each is scored and returned, even when the score is low.

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

Content looks for copied sentences and shared topics. Design looks at page layout, colours and fonts, custom code names and shared image files, and spots plain template matches. Design checks open each page in a browser, so they take longer.

## `minScore` (type: `integer`):

Used for the look-alike count in the summary report (0 to 100). Every site you list is returned with its score.

## `pagesPerSite` (type: `integer`):

How many pages of each website you check are read (home page plus linked about, services and product pages), 1 to 10. Copiers usually take several pages, so more pages find more copied sentences. Compared sites are read up to 3 pages.

## `onlyNew` (type: `boolean`):

Remember what was already returned for this website and return only new matches or ones whose score rose by 15 points or more. Schedule the Actor weekly to watch your list. The memory is a named store in your account.

## `watchName` (type: `string`):

Names the memory used by 'Only new matches', so you can keep several watch lists apart. Leave empty for the default.

## `saveImages` (type: `boolean`):

For scores of 60 or more, save a picture of your page next to theirs. The link is in the row.

## `makeReports` (type: `boolean`):

For scores of 60 or more, write a PDF with the scores, your copied sentences, Internet Archive first-seen dates and the side-by-side picture. Useful for a complaint to a host or to Google. The link is in the row.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.yourcompany.com"
  ],
  "compareWith": [
    "https://suspicious-copy.example"
  ],
  "checks": [
    "content",
    "design"
  ],
  "minScore": 40,
  "pagesPerSite": 4,
  "onlyNew": false,
  "watchName": "",
  "saveImages": true,
  "makeReports": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Each similar site with its score, verdict, reasons and a side-by-side image link.

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

Copied sentences and the individual scores behind each match.

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

Websites checked, sites compared, what could not be read, and cost.

## `report` (type: `string`):

One free row per website: what was found, and the closest sites even when nothing matched.

# 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 = {
    "startUrls": [
        "https://www.plumbers-leeds.com/"
    ],
    "compareWith": [
        "https://www.example.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("locaihost/website-similarity").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 = {
    "startUrls": ["https://www.plumbers-leeds.com/"],
    "compareWith": ["https://www.example.com/"],
}

# Run the Actor and wait for it to finish
run = client.actor("locaihost/website-similarity").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.plumbers-leeds.com/"
  ],
  "compareWith": [
    "https://www.example.com/"
  ]
}' |
apify call locaihost/website-similarity --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,locaihost/website-similarity"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1ogzmkhBSDyRv64dV/builds/T3VhBWoLMyNu53ooD/openapi.json