# XavvyNess AI Competitive Analyst (`xavvyness/xavvyness-competitive-intel`) Actor

Full competitive brief on any company: funding, pricing, reviews, tech stack, and marketing. Add your company name to get a head-to-head gap analysis automatically. Live web search data — not static databases. Support email: hello@xavvyness.ai

- **URL**: https://apify.com/xavvyness/xavvyness-competitive-intel.md
- **Developed by:** [XavvyNess](https://apify.com/xavvyness) (community)
- **Categories:** AI, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $35.00 / 1,000 company intelligence reports

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

## 🔍 XavvyNess Competitive Intel — Deep Company Research + Gap Analysis

Get a complete competitive intelligence report on any company — funding history, team size, product overview, pricing tiers, customer reviews, tech stack, and marketing strategy. Add your own company name and get a head-to-head gap analysis automatically.

> **The original Company Research actor has 2K runs.** We built on top of it with live Tavily search, multi-dimension coverage, and head-to-head gap analysis you can't get anywhere else on Apify.

### Demo

<!-- VIDEO_PLACEHOLDER: competitive-intel -->
> 🎬 **Video demo coming soon.** Upload `competitive-intel.mp4` to YouTube, then run `python3 scripts/actor-video-gen.py --embed-readmes` to embed it here automatically.

---

### 🚀 What It Does

1. Runs live web searches across 7 competitive dimensions for each company
2. AI synthesizes the raw data into structured, actionable intelligence
3. Optional: adds your company to generate a strategic gap analysis

**Perfect for:** sales prep, investor research, product strategy, market entry analysis, competitive positioning

---

### 📥 Input

| Field | Required | Default | Description |
|---|---|---|---|
| `companies` | ✅ | — | Company names or domains (e.g. "OpenAI" or "openai.com") |
| `yourCompany` | — | — | Your company name for gap analysis |
| `dimensions` | — | funding, product, pricing, reviews | Which aspects to research |
| `depth` | — | `standard` | `quick` / `standard` / `deep` |

**Available dimensions:** `funding`, `team`, `product`, `pricing`, `reviews`, `techstack`, `marketing`

**Example input:**
```json
{
  "companies": ["Anthropic", "OpenAI"],
  "yourCompany": "XavvyNess",
  "dimensions": ["product", "pricing", "reviews", "techstack"],
  "depth": "deep"
}
````

***

### 📤 Output

Real output from a live run comparing AI coding assistants:

```json
{
  "company": "GitHub Copilot",
  "overview": "GitHub Copilot is an AI coding assistant that boosts developer productivity by providing code suggestions, automating routine tasks, and offering inline chat and code review.",
  "founded": "2021",
  "teamSize": "1000+",
  "fundingTotal": "$41 million",
  "pricingModel": "Freemium — $10/month individual, $39/month business",
  "topStrengths": [
    "Deep integration within the developer workflow",
    "Improves productivity and speeds up tasks",
    "Backed by Microsoft/GitHub distribution"
  ],
  "topWeaknesses": [
    "Code quality issues in complex edge cases",
    "Over-reliance risk for junior developers",
    "Privacy concerns with code being sent to servers"
  ],
  "targetAudience": "Developers, programmers, and organizations",
  "strengthScore": "8",
  "opportunityGap": "Cursor can gain a competitive edge by focusing on more accurate suggestions, better edge case handling, and stronger privacy guarantees for enterprise customers.",
  "dimensions": ["funding", "product", "pricing", "reviews"],
  "researchedAt": "2026-04-08T22:26:10.617Z",
  "agent": "XavvyNess Competitive Intel"
}
```

Each company in the `companies` array gets its own result object. Add `yourCompany` to get strategic gap analysis automatically.

***

### 💡 Research Dimensions

| Dimension | What You Get |
|---|---|
| `funding` | Funding rounds, investors, total raised, valuation |
| `team` | Founders, key hires, team size, notable departures |
| `product` | Core features, recent launches, roadmap signals |
| `pricing` | All pricing tiers, per-unit costs, enterprise discounts |
| `reviews` | G2/Trustpilot/Reddit sentiment, common complaints |
| `techstack` | Known infrastructure, APIs, integrations, languages |
| `marketing` | Positioning, messaging, key channels, campaigns |

***

### ⚙️ Setup — API Keys

| Variable | Required | Where to Get |
|---|---|---|
| `TAVILY_API_KEY` | ✅ Required | [app.tavily.com](https://app.tavily.com) (free tier available) |
| `GROQ_API_KEY` | Recommended (free) | [console.groq.com](https://console.groq.com) |
| `GOOGLE_API_KEY` | Optional fallback | [aistudio.google.com](https://aistudio.google.com) |

***

### 🔗 Use Cases

1. **Sales prep** — Research a prospect's tech stack and competitive positioning before a call
2. **Market entry** — Map the competitive landscape before launching in a new segment
3. **Investor research** — Deep-dive on portfolio companies or potential investments
4. **Product strategy** — Find gaps in competitor offerings to inform your roadmap
5. **Partnership evaluation** — Understand a potential partner's financials and culture
6. **Pricing strategy** — Benchmark your pricing against the market in minutes

***

### 📊 Performance

- ✅ Standard research: ~30-60s per company
- ✅ Deep research with gap analysis: ~90-120s per company
- ✅ Live web data via Tavily (not static databases)
- ✅ Groq → Gemini fallback — never fails silently
- ✅ **Failed runs are not charged** — you only pay for successfully generated reports

***

### Integration

#### Via Apify JavaScript client

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

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

const run = await client.actor('QaKPkAQ0x8ynmYubk').call({
  companies: ['Anthropic', 'OpenAI', 'Cohere'],
  yourCompany: 'YourStartup',
  dimensions: ['product', 'pricing', 'reviews', 'techstack'],
  depth: 'standard',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(company => {
  console.log(company.company);        // Company name
  console.log(company.fundingTotal);   // Total funding raised
  console.log(company.pricingModel);   // Pricing structure
  console.log(company.opportunityGap); // Strategic gap vs. your company
  console.log(company.strengthScore);  // Competitive strength 0–10
});
```

#### Via HTTP API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/QaKPkAQ0x8ynmYubk/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": ["Anthropic", "OpenAI"],
    "dimensions": ["product", "pricing", "reviews"],
    "depth": "standard"
  }'
```

#### Via Make.com / Zapier

Use the **Apify** module → **Run Actor** action. Actor ID: `QaKPkAQ0x8ynmYubk`. Pass company names in the `companies` array, then map `{{opportunityGap}}` and `{{strengthScore}}` into your CRM or reporting workflow.

***

*Built by XavvyNess — AI agent services that do real work.*

# Actor input Schema

## `subjects` (type: `array`):

Names, domains, handles, or URLs. One per line. Works for companies, sports teams, creators, products, employers, candidates, real estate markets, or entertainment titles.

## `subjectType` (type: `string`):

What kind of subject you're researching. Leave as 'auto' to let the actor detect it automatically.

## `yourContext` (type: `string`):

Optional: your own company, team, product, or handle to generate a head-to-head gap analysis.

## `dimensions` (type: `array`):

Which aspects to research. Valid values depend on subject type.

## `depth` (type: `string`):

How deeply to research each subject.

## Actor input object example

```json
{
  "subjects": [
    "OpenAI",
    "Anthropic"
  ],
  "subjectType": "auto",
  "dimensions": [
    "funding",
    "product",
    "pricing",
    "reviews"
  ],
  "depth": "standard"
}
```

# 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 = {
    "subjects": [
        "OpenAI",
        "Anthropic"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xavvyness/xavvyness-competitive-intel").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 = { "subjects": [
        "OpenAI",
        "Anthropic",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xavvyness/xavvyness-competitive-intel").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 '{
  "subjects": [
    "OpenAI",
    "Anthropic"
  ]
}' |
apify call xavvyness/xavvyness-competitive-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "XavvyNess AI Competitive Analyst",
        "description": "Full competitive brief on any company: funding, pricing, reviews, tech stack, and marketing. Add your company name to get a head-to-head gap analysis automatically. Live web search data — not static databases. Support email: hello@xavvyness.ai",
        "version": "1.0",
        "x-build-id": "Gga6D8kRj6DQbEtEd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xavvyness~xavvyness-competitive-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xavvyness-xavvyness-competitive-intel",
                "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/xavvyness~xavvyness-competitive-intel/runs": {
            "post": {
                "operationId": "runs-sync-xavvyness-xavvyness-competitive-intel",
                "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/xavvyness~xavvyness-competitive-intel/run-sync": {
            "post": {
                "operationId": "run-sync-xavvyness-xavvyness-competitive-intel",
                "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": [
                    "subjects"
                ],
                "properties": {
                    "subjects": {
                        "title": "Subjects to Research",
                        "type": "array",
                        "description": "Names, domains, handles, or URLs. One per line. Works for companies, sports teams, creators, products, employers, candidates, real estate markets, or entertainment titles.",
                        "default": [
                            "OpenAI",
                            "Anthropic"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "subjectType": {
                        "title": "Subject Type",
                        "enum": [
                            "auto",
                            "company",
                            "sports_team",
                            "creator",
                            "product",
                            "employer",
                            "political_candidate",
                            "real_estate",
                            "entertainment"
                        ],
                        "type": "string",
                        "description": "What kind of subject you're researching. Leave as 'auto' to let the actor detect it automatically.",
                        "default": "auto"
                    },
                    "yourContext": {
                        "title": "Your Context (for gap analysis)",
                        "type": "string",
                        "description": "Optional: your own company, team, product, or handle to generate a head-to-head gap analysis."
                    },
                    "dimensions": {
                        "title": "Research Dimensions",
                        "type": "array",
                        "description": "Which aspects to research. Valid values depend on subject type.",
                        "default": [
                            "funding",
                            "product",
                            "pricing",
                            "reviews"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "depth": {
                        "title": "Research Depth",
                        "enum": [
                            "quick",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "How deeply to research each subject.",
                        "default": "standard"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
