# Competitor Website Analyzer - AI Competitive, SEO & Sales Brief (`entranced_gelato/ai-competitive-brief-generator`) Actor

Turn any public website URL into a structured competitive, SEO, or sales brief. Extracts positioning, messaging, pricing signals, tech stack, CTAs, and social links from the homepage plus key pages. Add your OpenAI key for an AI-written brief, or run free in extractive mode.

- **URL**: https://apify.com/entranced\_gelato/ai-competitive-brief-generator.md
- **Developed by:** [AIDevs](https://apify.com/entranced_gelato) (community)
- **Categories:** AI, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 brief generateds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

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

## AI Competitive Brief Generator

[![Competitor Website Analyzer](https://apify.com/actor-badge?actor=entranced_gelato/ai-competitive-brief-generator)](https://apify.com/entranced_gelato/ai-competitive-brief-generator)

**Turn any competitor or prospect URL into a structured competitive, SEO, or sales brief in seconds.**

Point it at a company's website and it analyzes the homepage plus key internal pages (pricing, about, product) and extracts positioning, messaging, pricing signals, tech stack, CTAs, and social presence. Choose the lens — **competitive**, **SEO**, or **sales** — and optionally add an AI-written narrative brief.

---

### Why AI Competitive Brief Generator

Manually researching a competitor or prospect takes 20–40 minutes of clicking around. This Actor does the first pass in under a minute and returns a structured, ready-to-use brief — the same input (a URL) producing three different deliverables depending on the lens you choose.

- **Three briefs, one Actor** — competitive intelligence, SEO research, or sales prospecting.
- **Structured + narrative** — always-on structured signals, plus an optional AI-written brief.
- **Free or premium** — runs in extractive mode with no key, or generates a narrative with your OpenAI key.

### When to use it

- **Competitive intelligence** — size up a rival's positioning, pricing, and differentiators.
- **SEO research** — surface a site's keyword themes, content gaps, and on-page strengths.
- **Sales prospecting** — understand what a prospect does, their likely pain points, and an outreach angle.

### When NOT to use it

- **Deep technical SEO audits** (Core Web Vitals, crawl budgets) — use a dedicated SEO crawler.
- **Private/intranet sites** — it reads public pages only.
- **Bulk lead lists** — it analyzes one company per run.

### Built for

Founders, product marketers, competitive-intelligence teams, sales reps, and agencies running this for multiple clients.

---

### How it works

1. **Fetch** the homepage at `url`.
2. **Follow key subpages** (optional) — pricing, about, product, features, customers, solutions.
3. **Extract signals** — title/positioning, messaging (headings), pricing mentions, detected tech stack, calls-to-action, and social links.
4. **Choose the lens** — `competitive`, `seo`, or `sales` shapes the analysis.
5. **(Optional) Narrative** — with an OpenAI key, generate a written brief tailored to the chosen lens.
6. **Output** one structured record; usage is billed per event.

### How to call it

#### From the Console
Paste a website into **Website URL**, pick a **Brief type**, optionally add your OpenAI key for a narrative, click **Start**, and read the **Output** tab.

#### From the API

````

POST https://api.apify.com/v2/acts/entranced\_gelato~ai-competitive-brief-generator/runs?token=\<APIFY\_TOKEN>
{
"url": "https://www.notion.so",
"briefType": "competitive",
"includeSubpages": true,
"maxSubpages": 3
}

````

Also callable over **MCP** as an agent tool.

---

### Input reference

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `url` | string | **Yes** | — | The website to analyze (competitor or prospect). |
| `briefType` | enum | No | `competitive` | `competitive`, `seo`, or `sales`. |
| `includeSubpages` | boolean | No | `true` | Also analyze key internal pages. |
| `maxSubpages` | integer | No | `3` | How many internal pages to add. |
| `openaiApiKey` | string (secret) | No | — | Your OpenAI key for the AI narrative brief. |
| `model` | string | No | `gpt-4o-mini` | OpenAI model used for the narrative. |

### Output reference

One dataset record per run:

| Field | Description |
|-------|-------------|
| `inputUrl` | The website analyzed. |
| `briefType` | The lens used: `competitive`, `seo`, or `sales`. |
| `mode` | `llm` (narrative) or `extractive` (structured only). |
| `brief` | Markdown narrative brief (only when an OpenAI key is supplied). |
| `structured` | Structured signals: company, tagline, key messaging, pricing signals, detected tech stack, social presence, CTAs. |
| `pages` | Per-page signals for each analyzed URL. |
| `generatedAt` | ISO timestamp of the run. |

---

### Pricing

**Pay per event** — charged per generated brief. The optional AI narrative uses your own OpenAI key, so the model's cost is billed by OpenAI separately and is never added to the Actor price. Apify platform/compute usage is included. See the **Pricing** tab for current rates.

### Integrations

- **CRM / sales tools** — drop briefs into deal notes or prospect records.
- **Make / Zapier / n8n** — URL in, brief out, routed to your stack.
- **MCP** — expose as a tool for autonomous research agents.

### 🔌 Integrations & code examples

#### Call it from the API

```bash
curl "https://api.apify.com/v2/acts/entranced_gelato~ai-competitive-brief-generator/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://www.notion.so", "briefType": "competitive", "includeSubpages": true }'
````

#### Python (Apify client)

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("entranced_gelato/ai-competitive-brief-generator").call(
    run_input={"url": "https://competitor.com", "briefType": "sales"}
)
brief = next(client.dataset(run["defaultDatasetId"]).iterate_items())
print(brief["structured"]["company"], "-", brief["structured"]["tagline"])
print(brief.get("brief", "(extractive mode - no narrative)"))
```

#### MCP — add it to Claude, Cursor, or any agent

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "entranced_gelato/ai-competitive-brief-generator"],
      "env": { "APIFY_TOKEN": "<APIFY_TOKEN>" }
    }
  }
}
```

Also works with **CRM tools**, **Make**, **Zapier**, and **n8n** — drop briefs straight into deal notes or prospect records.

#### Example output

```json
{
  "inputUrl": "https://competitor.com",
  "briefType": "competitive",
  "mode": "extractive",
  "structured": {
    "company": "Competitor Inc.",
    "tagline": "The all-in-one platform for X",
    "keyMessaging": ["Fast setup", "Enterprise-grade security", "Trusted by 10,000+ teams"],
    "pricingSignals": ["Free plan", "From $29/mo", "Custom enterprise pricing"],
    "techStack": ["React", "Segment", "Intercom"],
    "socialPresence": {"twitter": "@competitor", "linkedin": "company/competitor"},
    "ctas": ["Start free trial", "Book a demo"]
  },
  "pages": ["/", "/pricing", "/about"],
  "generatedAt": "2026-07-02T07:20:00.000Z"
}
```

### FAQ

**What's the difference between the three brief types?** Same input, different analysis: *competitive* focuses on positioning and differentiators; *seo* on keywords, content gaps, and meta quality; *sales* on pain points, buying signals, and outreach angle.

**Do I need an OpenAI key?** No — without one you get structured signals (extractive mode). Add a key for a written narrative.

**How many pages does it read?** The homepage plus up to `maxSubpages` key internal pages.

### Limitations

- One company per run.
- Public pages only.
- Heavily client-rendered sites may yield fewer signals.

### See also

- [AI Web Page Reader](https://apify.com/entranced_gelato/ai-web-page-reader) - any URL to clean text + Markdown.
- [AI Document Reader](https://apify.com/entranced_gelato/ai-document-reader) - PDF, DOCX, or file URL to clean text + Markdown.

# Actor input Schema

## `url` (type: `string`):

The public website you want a brief for (e.g. a competitor or a sales prospect).

## `briefType` (type: `string`):

What kind of brief to produce.

## `includeSubpages` (type: `boolean`):

Also fetch high-value internal pages (pricing, about, product) for a richer brief.

## `maxSubpages` (type: `integer`):

How many internal subpages to analyze in addition to the main page.

## `openaiApiKey` (type: `string`):

Supply your own OpenAI key to get a written narrative brief. Without it, the Actor returns structured signals only (extractive mode).

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

OpenAI model used when a key is supplied.

## Actor input object example

```json
{
  "url": "https://www.notion.so",
  "briefType": "competitive",
  "includeSubpages": true,
  "maxSubpages": 3,
  "model": "gpt-4o-mini"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "url": "https://www.apify.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("entranced_gelato/ai-competitive-brief-generator").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 = { "url": "https://www.apify.com" }

# Run the Actor and wait for it to finish
run = client.actor("entranced_gelato/ai-competitive-brief-generator").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 '{
  "url": "https://www.apify.com"
}' |
apify call entranced_gelato/ai-competitive-brief-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=entranced_gelato/ai-competitive-brief-generator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Competitor Website Analyzer - AI Competitive, SEO & Sales Brief",
        "description": "Turn any public website URL into a structured competitive, SEO, or sales brief. Extracts positioning, messaging, pricing signals, tech stack, CTAs, and social links from the homepage plus key pages. Add your OpenAI key for an AI-written brief, or run free in extractive mode.",
        "version": "0.0",
        "x-build-id": "2zLhiQauXphaFWPx8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/entranced_gelato~ai-competitive-brief-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-entranced_gelato-ai-competitive-brief-generator",
                "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/entranced_gelato~ai-competitive-brief-generator/runs": {
            "post": {
                "operationId": "runs-sync-entranced_gelato-ai-competitive-brief-generator",
                "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/entranced_gelato~ai-competitive-brief-generator/run-sync": {
            "post": {
                "operationId": "run-sync-entranced_gelato-ai-competitive-brief-generator",
                "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",
                "required": [
                    "url"
                ],
                "properties": {
                    "url": {
                        "title": "Website URL",
                        "type": "string",
                        "description": "The public website you want a brief for (e.g. a competitor or a sales prospect)."
                    },
                    "briefType": {
                        "title": "Brief type",
                        "enum": [
                            "competitive",
                            "seo",
                            "sales"
                        ],
                        "type": "string",
                        "description": "What kind of brief to produce.",
                        "default": "competitive"
                    },
                    "includeSubpages": {
                        "title": "Analyze key subpages",
                        "type": "boolean",
                        "description": "Also fetch high-value internal pages (pricing, about, product) for a richer brief.",
                        "default": true
                    },
                    "maxSubpages": {
                        "title": "Max subpages",
                        "minimum": 0,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many internal subpages to analyze in addition to the main page.",
                        "default": 3
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API key (optional)",
                        "type": "string",
                        "description": "Supply your own OpenAI key to get a written narrative brief. Without it, the Actor returns structured signals only (extractive mode)."
                    },
                    "model": {
                        "title": "LLM model",
                        "enum": [
                            "gpt-4o-mini",
                            "gpt-4o",
                            "gpt-4.1-mini"
                        ],
                        "type": "string",
                        "description": "OpenAI model used when a key is supplied.",
                        "default": "gpt-4o-mini"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
