# Peec AI Alternative: AI Visibility Tracking API (`khadinakbar/peec-ai-alternative`) Actor

Track a brand’s visibility across ChatGPT, Gemini, Claude, and Perplexity. Run current prompt-level AI answer audits with mentions, citations, source domains, sentiment, and timestamps.

- **URL**: https://apify.com/khadinakbar/peec-ai-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 ai visibility checks

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Peec AI Alternative: on-demand AI visibility audit

Run a current, prompt-level AI visibility audit for one public brand. This Actor sends a bounded set of buyer-intent prompts to the AI answer engines you select and returns one source-linked observation per prompt and platform: brand mention, approximate first-mention position, heuristic sentiment, competitor share of voice, owned-domain citation, source domains, answer excerpt, model route, and collection time.

Use it for a reproducible API-based snapshot you can export or rerun. It is designed for current prompt evidence and pairs well with specialized Google AI feature measurement or a multi-user monitoring suite when those are the next workflow step.

### What it replaces and what it does not

This is a **workflow alternative** for the narrow job of running a small, current, source-linked AI visibility audit from structured input. It does not replace Peec AI's dashboard, daily historical tracking, prompt/topic management, agency workspace, campaign reporting, product-shopping monitoring, crawlability checks, Google AI Overview/AI Mode coverage, or its broader MCP project-management surface.

### Quick start input

```json
{
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools",
  "competitors": ["Bright Data", "Octoparse"],
  "queryTemplates": ["recommendations", "alternatives", "category_leaders"],
  "platforms": ["perplexity", "chatgpt", "gemini"],
  "maxQueries": 3,
  "responseFormat": "concise"
}
```

`brandName` is the only required input. Add `targetDomain` to separately measure whether an owned page appeared in the returned sources. `maxQueries` is a hard input cap: the Actor creates at most that many unique prompts, then checks each selected platform. Start with one platform and one prompt when you are validating a new topic.

### Output: what each row means

| Field | Meaning |
| --- | --- |
| `platform` | The requested answer-engine route for this observation. |
| `query` | The exact buyer-intent prompt sent during the run. |
| `brandMentioned` | Whether the answer text named the tracked brand. |
| `brandPosition` | Approximate first-mention position in that answer; it is not a search-result rank. |
| `brandShareOfVoice` | Tracked-brand mentions divided by the tracked brand plus the supplied competitor mentions in this answer. |
| `sentiment` | Positive, neutral, or negative heuristic from the mention context. |
| `domainCited` / `citedUrls` | Whether the supplied owned domain was among extracted source URLs, plus all available URLs. |
| `sourceDomains` | Deduplicated domains derived from citations or grounding metadata. |
| `checkedAt` | UTC timestamp for this observation. |

Each completed row is a dated sample of an AI answer. Compare matching prompts, platforms, and settings across runs; use the row as prompt-level evidence rather than a durable ranking or causal explanation.

```json
{
  "runId": "exampleRun123",
  "platform": "perplexity",
  "query": "Which web scraping tools should a data team consider?",
  "queryCategory": "custom",
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "brandMentioned": true,
  "brandMentionCount": 2,
  "brandPosition": 1,
  "brandShareOfVoice": 0.5,
  "sentiment": "positive",
  "domainCited": true,
  "citedUrl": "https://apify.com/",
  "citedUrls": ["https://apify.com/"],
  "sourceDomains": ["apify.com"],
  "competitorMentions": ["Bright Data"],
  "competitorMentionCount": 2,
  "aiAnswerExcerpt": "Apify is a common choice for structured web data workflows.",
  "modelUsed": "perplexity/sonar",
  "checkedAt": "2026-08-31T12:00:00.000Z"
}
```

### Price and cost boundary

The proposed pricing contract is Pay per event plus Apify platform usage: `$0.10` for each validated `ai-visibility-check` row and `$0.00005` for Actor start. Platform usage is additional. A run with three prompts across three selected engines has a maximum of nine value events before any account-level charge cap.

Check the live Pricing tab after private deployment for the effective event record and exact per-run charges. Provider routes that produce useful observations create the documented value-event rows.

### API usage

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/peec-ai-alternative').call({
  brandName: 'Apify',
  targetDomain: 'apify.com',
  industry: 'web scraping tools',
  competitors: ['Bright Data', 'Octoparse'],
  platforms: ['perplexity'],
  maxQueries: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

After any run, read `OUTPUT` for the terminal outcome and `RUN_SUMMARY` for provider attempts, charges, completion counts, source-domain aggregates, and workflow guidance. `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, and `INVALID_INPUT` are distinct successful terminal states; `UPSTREAM_FAILED` and `CONFIG_ERROR` preserve the diagnostic needed to configure the next run.

### Agent prompt card

> Audit Apify's visibility for one buyer-intent question about web scraping tools. Check Perplexity only, compare Bright Data and Octoparse, and return the mention flag, share of voice, owned-domain citations, source domains, timestamp, plus the terminal `RUN_SUMMARY` outcome.

Keep an agent's call bounded by supplying the brand, a real prompt or one clear template category, selected platform(s), and a small `maxQueries`. The Actor is read-only with respect to the public brands and prompts supplied, so it works cleanly as a focused data-collection step.

### How this workflow compares with Peec AI

| Decision dimension | This Actor | Peec AI |
| --- | --- | --- |
| Scope | A bounded current snapshot for supplied prompts and selected routes. | A broader AI-search analytics platform with ongoing projects, dashboards, and reporting. |
| Input workflow | JSON input: one brand, optional domain and competitors, bounded prompts, and selected engines. | Project setup, tracked prompts, topics, and organization workflows. |
| Output contract | One flat record per prompt x platform plus explicit `OUTPUT` and `RUN_SUMMARY` records. | Product-level analytics, trends, prompt management, source analysis, and reports. |
| Billing and cost | Proposed event pricing is transparent in the Actor contract but awaits live charge verification. | Published subscription and credit plans; check Peec AI's current pricing before comparing a workload. |
| Effective efficiency | No same-job cost or time advantage is claimed until both products are observed on the same workload. | Better fit when a team needs its maintained historical dataset and dashboard workflow. |
| Integrations and automation | API-shaped runs and storage are declared; named MCP-client integrations will be added after an observed end-to-end test. | Peec documents its authenticated MCP server and project-level tools. |
| Freshness and provenance | Each observation declares a prompt, provider route, extracted sources, and UTC `checkedAt` timestamp. | Peec documents ongoing per-engine monitoring and trend analysis. |

Choose this Actor when the decision is specifically to obtain a small, machine-readable visibility sample at a known input boundary. Choose Peec AI when the decision requires its broader monitoring, analysis, collaboration, or engine coverage. This independent Actor is not affiliated, associated, or endorsed by Peec AI.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow. Start with a small prompt set, then pass the dated rows to your reporting, content-review, or analytics workflow. For a public multi-engine dashboard, use the [AI Search Brand Monitor](https://apify.com/khadinakbar/ai-search-brand-monitor) after this snapshot when that broader reporting step is the decision need.

### Best results and workflow guidance

- Use buyer questions that your prospective customers actually ask. Keep an identical prompt set for trend comparisons.
- Use `responseFormat: "detailed"` only when a human needs more answer context; concise rows keep downstream agent output smaller.
- Include only unambiguous competitor names. Share of voice is limited to the supplied names and the response text; it is not market-wide share.
- AI providers and their web grounding can change. Review a missing citation as a current observation and pair it with the prompt, source list, and timestamp.
- Treat the `recommendations` generated in `RUN_SUMMARY` as suggestions for human review and use the underlying evidence to guide the next content or source-coverage decision.

### Builder's note

I designed this Actor around prompt-level evidence because a visibility percentage without the prompt, answer route, source list, and collection time is hard to review responsibly. My goal is to make a small audit easy to rerun and export while keeping each observation clear enough for an analyst or agent to trace back to its exact input.

### Responsible use

Use public brands and prompts you are authorized to analyze. Keep prompts limited to public business context, and review provider terms, your organization's policies, and the underlying prompt, sources, response excerpt, and timestamp before making external claims.

# Actor input Schema

## `brandName` (type: `string`):

Use this when you want to track one brand, company, product, or tool in AI answers. Enter the public name exactly as customers write it, for example "Apify". Required for every real scan and prefilled for testing. Not a competitor list; put rivals in competitors.

## `targetDomain` (type: `string`):

Use this when you also want citation tracking for the brand website. Enter a bare domain such as "apify.com" or a URL like "https://apify.com". Defaults to blank, which skips owned-domain citation checks but still tracks brand mentions. Not a list of pages.

## `industry` (type: `string`):

Use this when built-in prompts should include the market category. Enter a short phrase such as "web scraping tools" or "CRM software". Defaults to "software tools" when blank. Not a keyword list; use queries for exact prompts.

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

Use this when you want share-of-voice against specific rivals. Enter brand names or domains, for example \["Bright Data", "Octoparse"]. Defaults to an empty list and accepts up to 10 values. Not the tracked brand; use brandName for that.

## `queries` (type: `array`):

Use this when you have exact customer questions to test. Enter one prompt per line, for example "What are the best web scraping tools?". Defaults to empty, so the actor generates prompts from queryTemplates. Not search keywords; these are full questions sent to AI platforms.

## `queryTemplates` (type: `array`):

Use this when you want standard buyer-intent prompt categories. Defaults to recommendations, alternatives, and category\_leaders. Choose from the listed values; each selected template may create multiple prompts before maxQueries caps the run. Not used to rewrite custom queries.

## `platforms` (type: `array`):

Use this to choose which AI answer engines to check. Defaults to \["perplexity", "chatgpt", "gemini"] for bounded cost. Add "claude" only when you explicitly need a deeper audit; Claude is token-capped. Not a model-id field.

## `maxQueries` (type: `integer`):

Use this to cap the number of unique prompts before multiplying by selected platforms. Defaults to 3, so the normal 3-platform run costs about $0.90 in event charges. Minimum 1 and maximum 10. Not the dataset item cap; each prompt x platform can create one row.

## `responseFormat` (type: `string`):

Use this to control how much AI-answer text is stored in each row. Defaults to "concise" for MCP and agent workflows. Choose "detailed" when a human will inspect answer context. Not a platform selector.

## `webhookUrl` (type: `string`):

Use this when another system should receive the run summary after completion. Enter an HTTPS endpoint such as "https://hooks.zapier.com/hooks/catch/...". Defaults to blank, so no webhook is sent. Not used for authentication or API keys.

## `demoMode` (type: `boolean`):

Use this when you want a no-charge connectivity check. When true, the actor writes OUTPUT and RUN\_SUMMARY without calling AI providers. Defaults to false for real scans. Not a cached visibility report.

## Actor input object example

```json
{
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools",
  "competitors": [
    "Bright Data",
    "Octoparse"
  ],
  "queries": [
    "What are the best web scraping tools?",
    "Is Apify good for data extraction?"
  ],
  "queryTemplates": [
    "recommendations",
    "alternatives",
    "category_leaders"
  ],
  "platforms": [
    "perplexity",
    "chatgpt",
    "gemini"
  ],
  "maxQueries": 3,
  "responseFormat": "concise",
  "webhookUrl": "https://hooks.zapier.com/hooks/catch/123/abc",
  "demoMode": false
}
```

# Actor output Schema

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

Dataset items, one per successful prompt x platform check.

## `output` (type: `string`):

Stable compact machine-readable outcome contract.

## `runSummary` (type: `string`):

Detailed diagnostics, metrics, provider attempts, platform scores, recommendations, charges, and warnings.

# 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 = {
    "brandName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/peec-ai-alternative").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 = {
    "brandName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/peec-ai-alternative").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 '{
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools"
}' |
apify call khadinakbar/peec-ai-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/peec-ai-alternative"
        }
    }
}

```

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/RxxkTyqscxVYSO3gJ/builds/MBXFdv4I0pqAY2mNF/openapi.json