# Apify Actor Visibility Monitoring: Apify AI/MCP, SEO, GEO/AEO (`inovaflow/apify-actor-visibility`) Actor

Where do AI agents (Apify MCP & Apify AI), Google (SEO) and answer engines (GEO/AEO) discover your Apify Actors? This audit shows where each ranks, whether AI picks your card, who outranks you, and the per-channel fixes — with a shareable report.

- **URL**: https://apify.com/inovaflow/apify-actor-visibility.md
- **Developed by:** [inovaflow](https://apify.com/inovaflow) (community)
- **Categories:** MCP servers, Developer tools, Agents
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 actor auditeds

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Apify Actor Visibility Monitoring: Apify AI/MCP, SEO, GEO/AEO

AI is becoming the front door to Apify. When someone asks an AI assistant — Claude or Cursor
through the Apify MCP server, or Apify's own **Apify AI** right inside Console — to *"scrape
Instagram comments"* or *"monitor my competitors' prices"*, it searches the Apify Store, reads
a handful of Actor cards, and picks **one** to run. If that pick isn't your Actor, that user
was never yours — and you'll never see it happen.

This Actor makes it visible. It runs the same searches an AI agent runs, records where
your Actor ranks, simulates which card the AI actually picks, and tells you — honestly —
what to fix. Run it regularly: rankings shift, competitors update their cards, and every
change you make to your title or description deserves a before/after check.

> **Now covers Apify AI.** Apify's new in-Console assistant, [Apify AI](https://blog.apify.com/introducing-apify-ai/),
> finds and runs Actors from plain-English prompts using the **same MCP tools and Store ranking** this
> audit already probes — so your MCP score is your Apify AI visibility, measured the same way. Add SEO
> and AEO to cover Google organic and the answer engines (Perplexity / ChatGPT / Gemini) as well.

**If you…**

- published an Actor and wonder why the MCP traffic goes to a competitor,
- just rewrote your title/description and want proof it worked,
- maintain a whole portfolio and want one score per Actor plus a strategy for each,
- are about to build a new Actor and want to know whether the niche is even winnable,

…this is the audit for you.

### What you get

- **A visibility score (0–100)** per Actor, split into the three things that decide AI
  traffic: *does the AI find you*, *how high do you rank*, and *does it actually pick
  your card*.
- **A breakdown by prompt difficulty** — broad ("keep tabs on my competitors"), medium
  ("monitor competitor websites"), and niche ("track pricing-page changes with Slack
  digests") — so you see exactly *where* you're invisible.
- **The competitors above you** for every query, with their runs, success rate, and
  pricing — plus the AI's own reasoning for why it picked whoever it picked.
- **A strategy per Actor**: keep competing, improve the copy, differentiate the card,
  niche down, pivot, or walk away — an honest market read with concrete next steps.
- **Three discovery channels**, all in the one flat per-Actor fee (no per-channel charge): **MCP /
  Apify AI** (the core — the Apify MCP server *and* Apify's in-Console **Apify AI**, which pick Actors
  from the same Store search), **SEO** (where your Store page actually ranks on Google page 1 for buyer
  queries, plus an on-page grade explaining why), and **GEO / AEO** (do Perplexity / ChatGPT / Gemini /
  AI Overviews name your Actor when asked *your own prompts* — **with no Apify MCP involved**; the full
  answers are returned).
- **One cross-source read** when you check more than one channel — the thing no single channel
  shows on its own, like ranking #1 for agents while no answer engine has ever heard of you.
- **An interactive, shareable report page**
  ([see a live multi-Actor example](https://api.apify.com/v2/key-value-stores/CiiVBFllhTYV61ymd/records/REPORT))
  with dark/light mode, filtering and sorting — opened and shared from a link at the end of every
  run — plus the structured dataset and OUTPUT for spreadsheets or automation, and an optional
  email summary.

### How to run it

- **Just add your username** (recommended). The run audits every public Actor you own
  across all three channels — the AI generates realistic test prompts and does the rest.
  Minimum inputs → full results.
- **Or check specific Actors.** List one or more Actors (`username/name` or IDs). If a
  username is also set, the username audit wins.
- **Your own prompts (optional).** In *"Optional full ownership"* the **prompts** field is
  a JSON map from an Actor to the exact prompts to test for it — tested **verbatim**, no AI
  rewriting. Any Actor not listed there gets AI-generated prompts.

Prompt generation reads **only the Actor's public metadata** (title, description,
categories, README) — the same card an AI agent sees. That keeps the audit reproducible
and honest: if the card undersells the use case, the low score IS the finding, and the
strategy tells you how to fix the card.

The AI runs on **Claude Haiku 4.5 (our included key)** by default — zero setup, and its
cost is why the fee stays flat. To run **Claude Sonnet, GPT or Gemini**, paste your own key
in *"Optional full ownership"* and pick the model there. This Actor always runs with a
model (it never degrades to a key-free heuristic).

### Pricing — flat, per Actor

**$0.10 per Actor audited** on our included AI key — or **$0.05 with your own key (BYOK)**.
Auditing 3 Actors is $0.30 (or $0.15 BYOK). Running more channels never adds a charge —
**MCP / Apify AI**, **SEO** and **GEO / AEO** are three lenses on the same audit, all in the
one fee. It covers everything: AI prompt generation, every search, the AI pick simulations,
the strategy, the shareable page and the email.

**Why $0.10 — and why BYOK is cheaper.** The fee mainly covers the **AI we run for you**:
Claude Haiku writes the prompts and simulates the picks, and one Claude Sonnet call reads
across all three channels. On our included key that AI is on us, so $0.10 is close to cost.
Bring your own AI key and *you* cover that AI — so the fee drops to $0.05. Either way the
SEO and GEO/AEO Google checks run on **your own** Apify account (connect it in *"Optional
full ownership"*), never on ours. An Actor whose audit couldn't complete is never billed.

**A fair budget: run it twice a week.** Visibility shifts as rivals ship and re-title, so
check after each improvement — twice weekly is a good cadence. That's **~$0.80 per Actor per
month** on our key ($0.40 BYOK) — against $20+/month for a typical SEO rank tracker that
doesn't even look at AI-agent or answer-engine discovery. Put the run on an Apify Schedule
and add your email in *"Email me the results"* for a summary with a link to the full report
every time.

### Advanced: how the measurement works

**The two layers of AI selection.**

1. **Eligibility gate.** The Store search the MCP calls returns only FREE /
   PAY_PER_EVENT / pay-per-result Actors. A rental/monthly Actor is structurally
   invisible to AI agents — it scores 0 regardless of keywords.
2. **Layer 1 — search recall.** The agent calls `GET /v2/store?search=` with short
   platform/data-type nouns. Ranking is text relevance (name, title, description,
   README) with popularity as a strong tiebreaker. For broad head terms the top slots
   are popularity-bound — you can't edit your way past a giant's run count.
3. **Layer 2 — the card pick.** The agent reads the returned cards (title, description,
   stats, pricing — not the full README) and chooses one. You can win Layer 2 at ranks
   3–8 with a sharper card.

**The prompts.** The AI generates `promptCount` (3–8, default 5) prompts spread across
broad / medium / niche specificity and varied intents (task, problem, comparison,
direct), each with up to 3 semantically different keyword phrasings — synonyms and
different noun focus, not truncations. Without an AI key, a deterministic fallback
derives prompts from the title and first description clause (tagged `heuristic` in the
data so degraded runs are visible).

**The score.**

> **Score = 45% discovery + 25% rank + 30% AI pick**

- *Discovery*: credit per prompt = 70% for being found at all + 30% × the fraction of
  phrasings that found you (one-exact-phrase visibility is fragile). Broad prompts weigh
  1.5×, medium 1×, niche 0.75× — being found from a vague request is the achievement.
- *Rank*: ranks 1–3 score 1.0 / 0.9 / 0.8 (near-equivalent — the pick decides among the
  top cards), then quality decays geometrically (rank 5 ≈ 0.45, rank 10 ≈ 0.11).
- *AI pick*: of the simulated selections that ran, the share your card won. Generated
  plans simulate one pick per specificity tier; your own typed prompts each get their own.
- When the AI-pick simulation never ran (no key), the score renormalizes over
  discovery + rank, and the report says the pick was never measured.

A prompt whose Store searches all failed is skipped — an API outage can't masquerade as
"not found" — and if every prompt fails, the Actor's audit errors and is never billed.
Scores from v0.6 onward are **not comparable** with earlier versions (the old formula
tested near-duplicate keyword ladders).

### Roadmap

All three channels are **live today**: MCP / Apify AI (Store-search discovery + the AI pick),
SEO (live Google page-1 rank + a keyless on-page grade that explains it), and GEO / AEO
(whether Perplexity / ChatGPT / Gemini / AI Overviews name your Actor for your own prompts),
plus the one cross-source read that ties them together. **Next:** tracking your scores across
runs, so you can watch a title or description rewrite move the number.

# Actor input Schema

## `username` (type: `string`):

Audits every public Actor you own. This alone is enough. Leave empty to check specific Actors instead.
## `actorIds` (type: `array`):

One or more Actors as "username/name" (e.g. apify/rag-web-browser) or Actor IDs. Ignored when a username is set above — the username audit wins.
## `sources` (type: `array`):

MCP / Apify AI (AI agents), SEO (Google page-1 rank), GEO / AEO (AI answer engines). Default: all three. The fee is per Actor, so adding channels never costs more.
## `publishPage` (type: `boolean`):

Build an interactive HTML page — scores, strategy, per-prompt ranks and the competitors above you — saved at a shareable link you can send anyone. See a live multi-Actor example: https://api.apify.com/v2/key-value-stores/CiiVBFllhTYV61ymd/records/REPORT — On by default; the dataset + OUTPUT are always saved.
## `outputEmail` (type: `string`):

Get a short branded summary emailed each run, with a button to open the page. From a no-reply address. Leave blank to skip.
## `prompts` (type: `object`):

Optional. A JSON object mapping an Actor to prompts tested VERBATIM (no AI rewriting). Keys are "username/name" or an Actor ID. Example: {"apify/rag-web-browser": ["Turn a URL into clean markdown for my LLM"], "apify/instagram-scraper": ["Download recent posts from a profile"]}. Any Actor you don't list gets AI-generated prompts. Leave empty to let the AI write everything (the default, recommended path).
## `aiModel` (type: `string`):

Which model to run when you paste a key below. No key = Claude Haiku on our included key (the default, no setup). This picker only takes effect once you provide a key.
## `llmApiKey` (type: `string`):

Anthropic / OpenAI / Google key matching the model above. Provide it to run on your own key at a lower per-Actor fee. Leave empty to use the included Claude Haiku key (no setup).
## `promptCount` (type: `integer`):

How many test prompts the AI writes per Actor (broad / medium / niche). Depth only — the per-Actor fee is the same.
## `searchVariants` (type: `integer`):

How many keyword phrasings to test per prompt you typed yourself. Doesn't change the fee.
## `competitorCount` (type: `integer`):

How many higher-ranked Actors to capture per query for the gap report.
## `includeLayer2` (type: `boolean`):

After finding your rank, ask the AI to pick one Actor from the same cards it sees — does it pick yours? Off = ranking + strategy only.
## `maxActors` (type: `integer`):

Cap for the username audit — each Actor is one flat charge. Only used when a username is set.
## `apifyMcpConnector` (type: `string`):

SEO and GEO/AEO run a public Google scraper that some plans can't. Connect your Apify account and the scrape runs, and bills, there. Channels that can't run are never charged.
## `apifyToken` (type: `string`):

Alternative to the connector: paste an API token for an account that can run public Actors (with prepaid usage). Empty = the account running this Actor.

## Actor input object example

```json
{
  "username": "apify",
  "actorIds": [
    "apify/rag-web-browser"
  ],
  "sources": [
    "mcp",
    "seo",
    "aeo"
  ],
  "publishPage": true,
  "outputEmail": "me@example.com",
  "aiModel": "claude-sonnet-byok",
  "promptCount": 5,
  "searchVariants": 3,
  "competitorCount": 5,
  "includeLayer2": true,
  "maxActors": 10
}
````

# Actor output Schema

## `report` (type: `string`):

The self-contained, interactive visibility page — the verdict, portfolio + per-Actor scores, sub-score bars, per-prompt ranks with the competitors above you and the AI's reasoning, the Organic SEO and AI-answer-engine cards for every source checked, dark/light mode. Written whenever the 'Generate a shareable visibility page' toggle is on (default).

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

The structured run verdict as JSON — per Actor the 0-100 MCP score, band, sub-scores, headline, next steps and strategy, plus the Organic SEO grade (`seo`) and AI-answer-engine result (`aeo`) for each source checked, the run's verdict (`synthesis`), and the portfolio score. Read this from any integration.

## `dataset` (type: `string`):

One row per prompt tested on the MCP source, with the keywords, rank, saturation and AI pick — export to CSV, JSON or Excel from the Console. The SEO and AEO sources are per-Actor verdicts, not per-prompt, so they live in OUTPUT and on the page.

# 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 = {
    "username": "apify",
    "actorIds": [
        "apify/rag-web-browser"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/apify-actor-visibility").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 = {
    "username": "apify",
    "actorIds": ["apify/rag-web-browser"],
}

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/apify-actor-visibility").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 '{
  "username": "apify",
  "actorIds": [
    "apify/rag-web-browser"
  ]
}' |
apify call inovaflow/apify-actor-visibility --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Actor Visibility Monitoring: Apify AI/MCP, SEO, GEO/AEO",
        "description": "Where do AI agents (Apify MCP & Apify AI), Google (SEO) and answer engines (GEO/AEO) discover your Apify Actors? This audit shows where each ranks, whether AI picks your card, who outranks you, and the per-channel fixes — with a shareable report.",
        "version": "1.2",
        "x-build-id": "isWMt1ZotDt1kFecS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/inovaflow~apify-actor-visibility/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-inovaflow-apify-actor-visibility",
                "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/inovaflow~apify-actor-visibility/runs": {
            "post": {
                "operationId": "runs-sync-inovaflow-apify-actor-visibility",
                "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/inovaflow~apify-actor-visibility/run-sync": {
            "post": {
                "operationId": "run-sync-inovaflow-apify-actor-visibility",
                "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",
                "properties": {
                    "username": {
                        "title": "Apify username (recommended)",
                        "type": "string",
                        "description": "Audits every public Actor you own. This alone is enough. Leave empty to check specific Actors instead."
                    },
                    "actorIds": {
                        "title": "Or check specific Actors",
                        "type": "array",
                        "description": "One or more Actors as \"username/name\" (e.g. apify/rag-web-browser) or Actor IDs. Ignored when a username is set above — the username audit wins.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Channels to check",
                        "type": "array",
                        "description": "MCP / Apify AI (AI agents), SEO (Google page-1 rank), GEO / AEO (AI answer engines). Default: all three. The fee is per Actor, so adding channels never costs more.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "mcp",
                                "seo",
                                "aeo"
                            ],
                            "enumTitles": [
                                "MCP / Apify AI",
                                "SEO — organic search",
                                "GEO / AEO — AI answers"
                            ]
                        },
                        "default": [
                            "mcp",
                            "seo",
                            "aeo"
                        ]
                    },
                    "publishPage": {
                        "title": "Generate a shareable report page",
                        "type": "boolean",
                        "description": "Build an interactive HTML page — scores, strategy, per-prompt ranks and the competitors above you — saved at a shareable link you can send anyone. See a live multi-Actor example: https://api.apify.com/v2/key-value-stores/CiiVBFllhTYV61ymd/records/REPORT — On by default; the dataset + OUTPUT are always saved.",
                        "default": true
                    },
                    "outputEmail": {
                        "title": "Email me the results",
                        "type": "string",
                        "description": "Get a short branded summary emailed each run, with a button to open the page. From a no-reply address. Leave blank to skip."
                    },
                    "prompts": {
                        "title": "Your own test prompts (per Actor)",
                        "type": "object",
                        "description": "Optional. A JSON object mapping an Actor to prompts tested VERBATIM (no AI rewriting). Keys are \"username/name\" or an Actor ID. Example: {\"apify/rag-web-browser\": [\"Turn a URL into clean markdown for my LLM\"], \"apify/instagram-scraper\": [\"Download recent posts from a profile\"]}. Any Actor you don't list gets AI-generated prompts. Leave empty to let the AI write everything (the default, recommended path)."
                    },
                    "aiModel": {
                        "title": "AI model (only used with your own key)",
                        "enum": [
                            "claude-sonnet-byok",
                            "claude-haiku-byok",
                            "gpt-4o-byok",
                            "gpt-4o-mini-byok",
                            "gemini-pro-byok",
                            "gemini-flash-byok"
                        ],
                        "type": "string",
                        "description": "Which model to run when you paste a key below. No key = Claude Haiku on our included key (the default, no setup). This picker only takes effect once you provide a key.",
                        "default": "claude-sonnet-byok"
                    },
                    "llmApiKey": {
                        "title": "Your AI API key (BYOK) — optional",
                        "type": "string",
                        "description": "Anthropic / OpenAI / Google key matching the model above. Provide it to run on your own key at a lower per-Actor fee. Leave empty to use the included Claude Haiku key (no setup)."
                    },
                    "promptCount": {
                        "title": "AI-generated prompts per Actor",
                        "minimum": 3,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many test prompts the AI writes per Actor (broad / medium / niche). Depth only — the per-Actor fee is the same.",
                        "default": 5
                    },
                    "searchVariants": {
                        "title": "Keyword variants per typed prompt",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many keyword phrasings to test per prompt you typed yourself. Doesn't change the fee.",
                        "default": 3
                    },
                    "competitorCount": {
                        "title": "Competitors to capture",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many higher-ranked Actors to capture per query for the gap report.",
                        "default": 5
                    },
                    "includeLayer2": {
                        "title": "Simulate the AI's pick (Layer 2)",
                        "type": "boolean",
                        "description": "After finding your rank, ask the AI to pick one Actor from the same cards it sees — does it pick yours? Off = ranking + strategy only.",
                        "default": true
                    },
                    "maxActors": {
                        "title": "Max Actors to check (username audit)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Cap for the username audit — each Actor is one flat charge. Only used when a username is set.",
                        "default": 10
                    },
                    "apifyMcpConnector": {
                        "title": "Run the Google checks on your account (recommended)",
                        "type": "string",
                        "description": "SEO and GEO/AEO run a public Google scraper that some plans can't. Connect your Apify account and the scrape runs, and bills, there. Channels that can't run are never charged."
                    },
                    "apifyToken": {
                        "title": "Apify token — run the Google checks on another account",
                        "type": "string",
                        "description": "Alternative to the connector: paste an API token for an account that can run public Actors (with prepaid usage). Empty = the account running this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```