# Integration Radar (`filipmasar/integration-radar`) Actor

Find the integrations your competitors offer and you don't, ranked by how many of them offer each one.

- **URL**: https://apify.com/filipmasar/integration-radar.md
- **Developed by:** [Filip Masár](https://apify.com/filipmasar) (community)
- **Categories:** Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 candidate founds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

Integration Radar finds **the integrations your competitors offer and you don't**.

Give it one company domain. It works out who that company competes with, lists what each competitor integrates with, and reports every third-party product they offer that the company doesn't — ranked by how many competitors offer it.

### What does Integration Radar do?

Enter a domain such as `apify.com`. In one run it:

1. **Names the competitors** — from an AI model's knowledge of the market, or from a list you supply.
2. **Lists what each one integrates with**, including your own company.
3. **Diffs and ranks** what's missing, merging spelling variants so "AWS S3" and "Amazon S3" count once.

It answers from the model's knowledge of these companies. No websites are crawled, which makes a run fast and cheap — and means the results reflect what the model knows rather than what a page says today. See [Limitations](#limitations).

Use it to decide what to integrate next, or to sketch an integrations roadmap. Run it on demand or on a schedule, and send the results to Google Sheets, Slack or a webhook through Apify's integrations.

### Input

| Field            | Type             | Required | Default | Description                                                               |
| ---------------- | ---------------- | -------- | ------- | ------------------------------------------------------------------------- |
| `companyDomain`  | string           | Yes      | —       | The company to analyze, as a bare domain: `apify.com`.                    |
| `maxCompetitors` | integer          | No       | `20`    | How many competitors to compare against, 1 to 30. Most-direct-first.      |
| `competitors`    | array of strings | No       | `[]`    | Explicit competitor domains. When set, these replace automatic discovery. |

```json
{
    "companyDomain": "apify.com",
    "maxCompetitors": 20
}
```

Pass `competitors` when you know the market better than a model does. Entries that aren't bare domains are dropped with a warning in the log.

### Output

One row per product your competitors offer and you don't, ranked by `competitorCount`, capped at the top 100. Export as JSON, CSV, Excel or HTML.

```json
[
    {
        "candidate": "Google Sheets",
        "slug": "google-sheets",
        "competitorCount": 4,
        "carriedBy": ["browse.ai", "phantombuster.com", "agenty.com", "dexi.io"],
        "description": "Cloud-based spreadsheet application for creating and editing tabular data.",
        "category": "spreadsheet",
        "status": "SEEN"
    }
]
```

| Field             | Description                                                                 |
| ----------------- | --------------------------------------------------------------------------- |
| `candidate`       | The product name.                                                           |
| `slug`            | Normalized name used to merge spelling variants.                            |
| `competitorCount` | How many competitors offer it. The ranking key, and your confidence column. |
| `carriedBy`       | The competitor domains it was attributed to.                                |
| `description`     | One factual sentence on what the product is.                                |
| `category`        | Short label such as `crm`, `spreadsheet`, `vector-database`.                |
| `status`          | `BASELINE`, `NEW` or `SEEN` — see below.                                    |

#### NEW, SEEN and BASELINE

Each run saves what it found for that domain and compares the next run against it.

- **First run:** every row is `BASELINE` — there's nothing to compare with yet.
- **After that:** `NEW` if the row wasn't in the previous list, `SEEN` if it was.

The comparison only holds if both runs compare the same companies, so changing `maxCompetitors` or `competitors` resets to `BASELINE` for one run.

### How much does it cost?

Pay-per-event, **$0.02** each:

- **`source-analyzed`** — one company's integration list looked up. Lists are cached for 24 hours and cached lookups are free.
- **`candidate-found`** — one row written to the dataset. Capped at 100 rows.

At the default `maxCompetitors: 20` a first run looks up at most 21 companies, so **$0.42 at most in lookups**, plus $0.02 per row. Rows dominate the bill: a full 100 rows is $2.00, giving a ceiling of **$2.42 per run**. A re-run within 24 hours pays only for rows.

A run that fails charges nothing — events are billed only once rows are written.

### Limitations

- **The answer comes from an AI model's knowledge, not from your competitors' websites.** Nothing is verified against a live page. Treat the output as a well-informed starting list to check, not as a source of record.
- Coverage tracks how well-known a company is. A large company with a public integrations catalogue is described well; a small or very new one may return nothing, and is then skipped.
- An integration added recently may be missing, because the model's knowledge has a cutoff.
- A row with `competitorCount: 1` rests on a single competitor. Sort by `competitorCount` and treat the tail with suspicion.
- Names can be wrong or oddly spelled. `carriedBy` names the competitors a row was attributed to, so you can sanity-check it.
- The run fails outright if no integrations can be listed for your own company, if no competitors can be determined, or if not one competitor produced a list. Each would otherwise produce a confidently wrong list.

### Feedback and support

Something looks wrong? Open an issue on the **Issues** tab with the run ID and the domain you ran. You're responsible for using the output in line with the terms of the sites involved.

# Actor input Schema

## `companyDomain` (type: `string`):

The company to analyze, as a bare lowercase domain with no "https://". Its competitors are identified automatically, or supplied via the "competitors" input.

## `maxCompetitors` (type: `integer`):

How many competitors to compare against. They are ordered most-direct-first, so a lower number keeps the closest competitors and drops the rest.

## `competitors` (type: `array`):

Optional. Explicit competitor domains, as bare domains such as "rival.com". When set, these are used instead of identifying competitors automatically.

## Actor input object example

```json
{
  "companyDomain": "apify.com",
  "maxCompetitors": 20,
  "competitors": []
}
```

# Actor output Schema

## `candidates` (type: `string`):

Integrations the competitors carry and the analyzed company does not, ranked by how many competitors carry each one.

# 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 = {
    "companyDomain": "apify.com",
    "competitors": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("filipmasar/integration-radar").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 = {
    "companyDomain": "apify.com",
    "competitors": [],
}

# Run the Actor and wait for it to finish
run = client.actor("filipmasar/integration-radar").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 '{
  "companyDomain": "apify.com",
  "competitors": []
}' |
apify call filipmasar/integration-radar --silent --output-dataset

```

## MCP server setup

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

```

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/Ft579PxjcIqfCLHax/builds/lqghpfeY8jvDQ2eGk/openapi.json