# Profound AI Alternative — Visibility Snapshots (`khadinakbar/profound-ai-alternative`) Actor

Run bounded, source-labeled model API checks for a brand and named competitors. Export each AI-answer visibility snapshot as structured JSON for scheduled monitoring.

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

## Pricing

from $50.00 / 1,000 ai answer visibility snapshots

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

## Profound AI Alternative — AI Answer Visibility Snapshots

Create a structured, timestamped snapshot of how selected model APIs describe one brand in the exact prompts you provide. It is for SEO, GEO, and competitive-intelligence teams that need an on-demand JSON record—not a dashboard screenshot—of a current answer-text check.

Use it when you already know the brand, competitor names, and questions to check. For real-user prompt-volume data, a historical answer-engine database, AI crawler traffic logs, content agents, or a broad platform workflow, Profound is the appropriate route.

Each saved row is one `brand × prompt × model API` observation with the exact prompt, model identifier, response boundary, brand mention count, named-competitor counts, answer-text share of voice, parsed URLs, bounded answer text, and collection time. The Actor charges **$0.00005 per run** plus **$0.05 per persisted AI-answer snapshot**, with Apify platform usage charged separately.

> This independent Actor is not affiliated, associated, or endorsed by Profound.

### What this Actor does

The Actor sends supplied prompts to selected managed model APIs: `openai`, `perplexity`, or `gemini`. It then applies deterministic exact-name matching to a target brand and any competitor names you supply. URL fields are parsed only from the returned answer text and are clearly labeled as such.

The returned model API answer can differ from a consumer answer-engine product, including its product-specific search, personalization, region, subscription tier, tools, and response-time behavior. Treat every row as a source-labeled API snapshot at its `collectedAt` time—not as a universal visibility score or a claim about what every user sees.

### When to use it

- You have a focused prompt set and need a current, structured answer-text snapshot.
- You want to schedule a repeatable brand-versus-named-competitor check.
- You need API-ready JSON with prompt, model, collection-time, and explicit match semantics.
- You need a bounded workflow that can feed your own reporting, alerting, or review process.

### When not to use it

- You need real-user prompt-volume data, historical answer-engine reporting, or a market-wide panel dataset.
- You need a broad platform with dashboards, collaboration, content agents, or crawler and traffic analytics.
- You need independently verified citations or a universal claim about consumer answer-engine behavior.

### Scope and complementary workflows

- Profound fits licensed real-user prompt volumes, demographic modeling, or market-wide prompt demand.
- Profound also fits multi-month historical databases, dashboard collaboration, content-generation agents, and server/CDN AI crawler analytics.
- Pair this Actor with human review when prompt discovery, competitor discovery, external URL verification, or citation assessment is required.
- Use the selected model API route when an identified API response is the desired measurement surface.

Start with this Actor for answer-text visibility, then use [AI SEO Tracker](https://apify.com/khadinakbar/ai-seo-tracker) for a site-level technical audit of crawlability, metadata, robots, sitemap, and `llms.txt`. AI SEO Tracker audits public web properties while this Actor focuses on model API answers.

### Input

`brandName` and `prompts` are required. Keep the questions specific to the customer decision you want to inspect. Add `brandDomain` only when you want to flag parsed answer URLs that match that domain; it is not an independent citation verifier.

```json
{
  "brandName": "Example Analytics",
  "brandDomain": "example.com",
  "competitors": ["Rival Analytics", "Another Analytics"],
  "prompts": [
    "Which analytics platform is best for a small B2B SaaS team?",
    "What are practical alternatives to Example Analytics for product analytics?"
  ],
  "engines": ["perplexity", "gemini"],
  "maxResponses": 4,
  "responseFormat": "concise"
}
```

`maxResponses` caps all `prompt × engine` combinations before model requests begin. Use `dryRun: true` to validate a scheduling or API payload without requesting model answers or charging the snapshot event.

### Output

Every dataset record is a single model API response, not an aggregated dashboard report.

| Field | Meaning |
| --- | --- |
| `prompt`, `engine`, `model` | Exact supplied prompt and selected provider model route. |
| `responseSource` | Always `model_api`; this is the data-provenance boundary. |
| `brandMentioned`, `brandMentionCount` | Exact-name match result in returned answer text. |
| `brandShareOfVoice` | Brand exact mentions ÷ (brand + supplied competitor exact mentions), or `null` when neither appears. |
| `competitorsMentioned`, `competitorMentionCounts` | Names from your list and their exact match counts. |
| `sourceUrls`, `citedBrandUrls` | URLs parsed from answer text; brand URLs are only hostname matches to `brandDomain`. |
| `mentionContext`, `sentiment` | Bounded text near the first mention and a simple keyword heuristic—not a human sentiment verdict. |
| `answerText`, `collectedAt` | Returned answer text and ISO 8601 collection timestamp. |

Example abbreviated record:

```json
{
  "recordType": "ai-answer-visibility-snapshot",
  "brandName": "Example Analytics",
  "prompt": "Which analytics platform is best for a small B2B SaaS team?",
  "engine": "perplexity",
  "model": "perplexity/sonar",
  "responseSource": "model_api",
  "brandMentioned": true,
  "brandMentionCount": 1,
  "brandShareOfVoice": 0.5,
  "competitorsMentioned": ["Rival Analytics"],
  "sourceUrls": ["https://example.com/docs"],
  "citedBrandUrls": ["https://example.com/docs"],
  "collectedAt": "2026-08-31T12:00:00.000Z"
}
```

`OUTPUT` always contains the terminal outcome, counters, billing counts, and warnings. `RUN_SUMMARY` adds parsed input, individual model-attempt diagnostics, start/finish times, stop reason, and cost estimate. Valid outcomes are `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, and `CONFIG_ERROR`.

### Pricing and cost boundaries

| Event | Price | When it applies |
| --- | ---: | --- |
| Actor start | $0.00005 | Once for each run. |
| AI answer visibility snapshot | $0.05 | Once for each validated dataset item persisted. |
| Platform usage | Separate | Apify compute and any platform usage are paid by the user when enabled. |

A one-prompt, one-engine run that persists **1 record** has declared event charges of **$0.05005** before separate platform usage. A run that persists **4 records** has declared event charges of **$0.20005** before separate platform usage. The Actor does not charge a snapshot event for invalid input, dry runs, or model attempts that return no usable answer.

The actor owner manages the model-provider credential. A provider response is required before a billable snapshot can be saved. This local pricing declaration is not live billing evidence until a deployed private canary has inspected event charges.

The live Actor **Pricing** tab is the current source of truth for **Pay per event** prices and **platform usage**. This README explains the declared launch contract so buyers and agents can estimate a bounded run before calling it.

### API example

Replace the placeholder token after the Actor is privately deployed. Keep Apify tokens in an authorization header or secure environment variable rather than a URL or shared dataset.

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~profound-ai-alternative/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "brandName": "Example Analytics",
    "prompts": ["Which analytics platform is best for a small B2B SaaS team?"],
    "engines": ["perplexity"],
    "maxResponses": 1
  }'
```

Use the returned run's default dataset ID to retrieve the structured rows. The hosted MCP contract has been exercised by a Codex client: it discovered the typed Actor tool, completed a bounded run, and retrieved the persisted structured row. That path does not imply a universal client compatibility or model-output guarantee.

### Agent prompt card

> Run a bounded current AI-answer snapshot for **\[brand]**. Use these exact prompts: **\[prompts]**. Compare only these named competitors: **\[competitors]**. Query **\[engines]**, cap the run at **\[maxResponses]** snapshots, and return the dataset rows plus `OUTPUT`. Treat the result as a source-labeled model API snapshot, not real-user prompt-volume data or a universal visibility score.

### How this workflow compares with Profound

Profound is the better fit when you need its broader platform: real-user prompt-volume data, historical reporting, multiple answer-engine coverage, dashboard collaboration, agents, content workflows, or AI crawler/traffic analytics. Its official pricing page currently lists a recurring Starter plan with a different included scope.

This Actor is only an on-demand alternative for the narrow workflow of sending **your supplied prompts** through **selected model APIs** and exporting a **timestamped structured snapshot**. It does not make a lower-cost, faster, more reliable, or full-suite-replacement claim against Profound. The private [comparison dossier](./ALTERNATIVE_ACTOR_DOSSIER.json) records the dated scope and pricing evidence; a same-job cloud-run cost comparison remains unverified.

| Decision area | This Actor | Profound / current boundary |
| --- | --- | --- |
| Workflow scope | One supplied brand, prompts, selected model APIs, and structured response rows. | Broader answer-engine visibility platform and reporting workflow. |
| Prompt volumes | Does not provide real-user prompt-volume data. | Its official materials describe licensed opt-in panel prompt data. |
| Output provenance | Each declared row stores prompt, model, `responseSource`, and `collectedAt`. | Its documented reporting API returns platform-owned visibility report data. |
| Input friction | Requires a brand name and one to ten supplied prompts; it does not use a Profound account. | Its API works against its own authenticated data model. |
| Cost | Uses an event price per persisted snapshot, plus separate platform usage; final validation reconciles expected snapshots with primary events, but no all-in same-job comparison is claimed. | Uses a different recurring-plan scope; no same-job allocation has been measured. |
| Effective efficiency | A bounded snapshot workflow; no same-workload throughput or active-review-time comparison is claimed. | No authorized same-job comparison was run. |
| Automation | The same saved input can be rerun; a live scheduled-workflow evaluation is pending. | Broader platform automation is outside this Actor's tested scope. |
| Reliability | Final validation covers normal, diagnostic, cap, and selected-model paths; it is not a production reliability guarantee. | No same-job reliability test was performed. |

### Best results and workflow guidance

- Keep brand and competitor names unambiguous. Exact matching will not infer aliases, subsidiaries, or pronouns.
- Use realistic customer questions. The Actor does not claim they represent real consumer prompt volumes.
- Repeat the same saved input on a schedule if you want a buyer-owned time series; compare rows only when engine, prompt, response format, and named competitor list are stable.
- Review `answerText` and `mentionContext` before acting on the calculated fields. They are mechanical observations, not research conclusions.
- Treat parsed URLs as answer-text observations and confirm source attribution in the relevant answer-engine or source workflow when that decision matters.

### Responsible use and data handling

The Actor sends supplied prompts to managed model APIs and stores returned answer text, calculated fields, and terminal diagnostics in your Apify storage. Submit only data you are authorized to use, and follow the applicable Apify and model-provider terms. This is a read-only monitoring workflow; it leaves brands, websites, models, and third-party accounts unchanged.

### Builder's note

I designed this Actor to favor a narrow, reproducible record over a vague overall score. My goal is for every row to preserve the question, selected model API, returned text, exact matching rule, parsed URLs, and collection time so a human or downstream system can inspect the observation in context.

### Current evidence status

The private release candidate has local tests, static schema/readiness checks, live pricing and metadata readback, a final cloud acceptance matrix with output and charge reconciliation, and a hosted-MCP client run with structured dataset retrieval. The private release-evidence log is the authoritative audit record; the Store page makes no production uptime, accuracy, cost-comparison, or full-suite-replacement claim.

# Actor input Schema

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

The brand or product to look for in model answers, for example 'Example Analytics'. Use the precise public name customers recognize. This is not a competitor list or a domain; supply those in their separate fields.

## `prompts` (type: `array`):

One to ten customer-style questions to send to each selected model API. Example: 'Which analytics platform is best for a small B2B SaaS team?'. These are supplied prompts, not observed consumer prompt-volume data.

## `brandDomain` (type: `string`):

Optional primary website domain used to identify URLs in a returned answer that belong to the brand, for example 'example.com'. URLs and bare domains are accepted. This does not prove a model cited or ranked the domain outside the returned answer text.

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

Optional list of up to ten competitor names used for a simple answer-text share-of-voice calculation. Example: \['Rival Analytics', 'Another Analytics']. It does not discover competitors or estimate market share.

## `engines` (type: `array`):

Choose the model APIs to query through the actor owner's managed provider. Valid values are 'openai', 'perplexity', and 'gemini'; the default is 'perplexity'. A model API response can differ from a consumer answer-engine product or its web-search experience.

## `maxResponses` (type: `integer`):

Hard cap on model-answer snapshots for this run. Each prompt × engine pair creates at most one billable persisted snapshot. Defaults to the smaller of ten or the supplied prompt count; this is not a token or output-row limit.

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

Choose 'concise' for shorter model answers or 'detailed' for more response context. The actor stores the returned answer text together with its calculated visibility fields. This setting does not change the underlying model's factual accuracy.

## `dryRun` (type: `boolean`):

When enabled, validates the request and writes terminal run artifacts without contacting a model API or charging answer snapshots. Use it to test scheduling or integrations. It does not prove model availability or output quality.

## Actor input object example

```json
{
  "brandName": "Example Analytics",
  "prompts": [
    "Which analytics platform is best for a small B2B SaaS team?"
  ],
  "brandDomain": "example.com",
  "competitors": [
    "Rival Analytics"
  ],
  "engines": [
    "perplexity",
    "gemini"
  ],
  "maxResponses": 5,
  "responseFormat": "concise",
  "dryRun": false
}
```

# Actor output Schema

## `snapshots` (type: `string`):

One dataset item per returned model answer and supplied prompt.

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

Compact terminal outcome, counters, charges, and warnings.

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

Detailed input, model-attempt, and terminal diagnostics.

# 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": "Example Analytics",
    "prompts": [
        "Which analytics platform is best for a small B2B SaaS team?"
    ],
    "brandDomain": "example.com",
    "competitors": [
        "Rival Analytics"
    ],
    "engines": [
        "perplexity"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/profound-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": "Example Analytics",
    "prompts": ["Which analytics platform is best for a small B2B SaaS team?"],
    "brandDomain": "example.com",
    "competitors": ["Rival Analytics"],
    "engines": ["perplexity"],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/profound-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": "Example Analytics",
  "prompts": [
    "Which analytics platform is best for a small B2B SaaS team?"
  ],
  "brandDomain": "example.com",
  "competitors": [
    "Rival Analytics"
  ],
  "engines": [
    "perplexity"
  ]
}' |
apify call khadinakbar/profound-ai-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/profound-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/eI1El5dle6zgUwpVm/builds/xWFCBF5N4hjOfv6rQ/openapi.json