# Free Website Analyzer for AI — Copy Any Site's Design (`geniuslead/website-mcp-server`) Actor

Free — only pay Apify platform costs. Extract CSS, fonts, colors, frameworks & page structure from any website via MCP. For competitive analysis, branding research & website cloning. Works with Claude, Cursor & ChatGPT. By GeniusLead

- **URL**: https://apify.com/geniuslead/website-mcp-server.md
- **Developed by:** [Genius Lead](https://apify.com/geniuslead) (community)
- **Categories:** Developer tools
- **Stats:** 6 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Website MCP Server

Give your AI full access to any website's design system — colors, fonts, CSS, images, code, and structure. No browser needed.

### What it does

This MCP server downloads a complete website and makes every file queryable through 6 AI tools. Your AI can extract color palettes, read CSS files, find font stacks, detect frameworks, search for class names, and parse page structure — all from a single URL.

### How it works

````

You: "Analyze the design of stripe.com"

AI → scrape\_website({ url: "https://stripe.com" })
← Downloaded 87 files (HTML, CSS, JS, images, fonts)

AI → get\_overview({ siteId: "a1b2c3" })
← Colors: #635bff, #0a2540, #ffffff
← Fonts: Inter, system-ui
← Frameworks: Next.js, Tailwind CSS

AI → search\_content({ siteId: "a1b2c3", query: "font-family", fileType: "css" })
← 12 matches across 3 files

AI → get\_file({ siteId: "a1b2c3", path: "stripe.com/css/main.css" })
← \[full CSS content ready for your AI to use]

```

### Tools

| Tool | What it does |
|------|-------------|
| `scrape_website` | Download an entire website — HTML, CSS, JS, images, fonts. Returns a site ID for all other tools. |
| `list_files` | List all downloaded files. Filter by type: `html`, `css`, `js`, `images`, `fonts`, or `all`. |
| `get_file` | Read the full content of any file — CSS, HTML, JS, config files. Binary files return metadata. |
| `get_page` | Parse an HTML page: title, headings, links, images, stylesheets, scripts. Defaults to index page. |
| `search_content` | Search across all files — like grep for the whole website. Find colors, class names, specific text. |
| `get_overview` | Instant design analysis: color palette, font stack, detected frameworks, file counts. |

### Input Parameters

#### `scrape_website`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `url` | string | Yes | The website URL to download |
| `depth` | number | No | How many levels deep to crawl (1-5, default: 3) |

#### `list_files`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `siteId` | string | Yes | Site ID from scrape_website |
| `type` | string | No | Filter: `html`, `css`, `js`, `images`, `fonts`, `all` (default: `all`) |

#### `get_file`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `siteId` | string | Yes | Site ID from scrape_website |
| `path` | string | Yes | File path from list_files output |

#### `get_page`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `siteId` | string | Yes | Site ID from scrape_website |
| `url` | string | No | Specific page URL (default: index page) |

#### `search_content`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `siteId` | string | Yes | Site ID from scrape_website |
| `query` | string | Yes | Search term (text, regex supported) |
| `fileType` | string | No | Limit search to file type: `css`, `html`, `js`, etc. |

#### `get_overview`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `siteId` | string | Yes | Site ID from scrape_website |

### Use Cases

#### For Designers
Extract the complete design system from any website. Get the exact color palette, font stack, and spacing — no more guessing from screenshots.

#### For Agencies
Run competitive analysis across multiple client competitors. Compare design systems, frameworks, and tech stacks side by side.

#### For AI Coding Agents
Build website clones or reference existing designs. Your AI reads the actual CSS and HTML — pixel-perfect results instead of guessing from screenshots.

#### For Content Migration
Moving to a new platform? Extract all assets, content structure, and styling from the old website automatically.

### How to Connect

#### Apify Standby (Remote)
Connect any MCP-compatible AI tool to the Standby URL:

```

https://website-mcp-server.geniuslead.apify.actor/mcp

````

#### Claude Desktop (Local)
Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "website": {
      "command": "npx",
      "args": ["-y", "website-mcp-server"]
    }
  }
}
````

#### Cursor

Add to your MCP settings with the same configuration as Claude Desktop.

### Compatibility

Works with any MCP-compatible AI tool:

- Claude (Desktop & API)
- Cursor
- ChatGPT (with MCP plugin)
- Windsurf
- Any MCP client

### Pricing

$0.05 per website scraped via Apify pay-per-event pricing.

### Technical Details

- **Download method:** wget with full mirror mode (preserves site structure)
- **Supported assets:** HTML, CSS, JavaScript, images (PNG, JPG, SVG, WebP, GIF), fonts (WOFF, WOFF2, TTF, OTF, EOT), data files (JSON, XML, CSV)
- **Framework detection:** Next.js, Nuxt, React, Vue, Angular, Svelte, WordPress, Shopify, Webflow, Tailwind CSS, Bootstrap, and more
- **Caching:** Downloaded sites are cached for 1 hour to avoid redundant downloads
- **Security:** Path traversal protection, file size limits, timeout handling

### Links

- [GeniusLead](https://geniuslead.de) — Built by GeniusLead
- [MCP Protocol](https://modelcontextprotocol.io) — Learn about MCP

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("geniuslead/website-mcp-server").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("geniuslead/website-mcp-server").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 '{}' |
apify call geniuslead/website-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=geniuslead/website-mcp-server",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Free Website Analyzer for AI — Copy Any Site's Design",
        "description": "Free — only pay Apify platform costs. Extract CSS, fonts, colors, frameworks & page structure from any website via MCP. For competitive analysis, branding research & website cloning. Works with Claude, Cursor & ChatGPT. By GeniusLead",
        "version": "1.0",
        "x-build-id": "cz95ZBS0JXIjlZsf9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/geniuslead~website-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-geniuslead-website-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/geniuslead~website-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-geniuslead-website-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/geniuslead~website-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-geniuslead-website-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {}
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```