# GEO Visibility Audit Intelligence (`jumpy_invoice/geo-visibility-audit-intelligence`) Actor

Audit brand and page readiness for AI search visibility, citations, prompts, and answer-engine recommendations.

- **URL**: https://apify.com/jumpy\_invoice/geo-visibility-audit-intelligence.md
- **Developed by:** [Bipeng Fu](https://apify.com/jumpy_invoice) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## GEO Visibility Audit Intelligence

Audit whether a brand, website, or landing page is ready to be found, cited, and recommended by AI search systems.

This Apify Actor is designed for SEO freelancers, content agencies, SaaS founders, and local business marketers who are trying to understand why their brand is not showing up in ChatGPT, Perplexity, Gemini, Google AI Overviews, or other AI-assisted discovery flows.

### What It Produces

- AI citation readiness score from `0-100`
- Brand/entity clarity assessment
- Direct-answer block recommendations
- FAQ and answer-engine gap analysis
- Schema recommendations for `Organization`, `SoftwareApplication`, `Product`, `FAQPage`, `HowTo`, or `LocalBusiness`
- Competitor comparison prompts and content gaps
- Third-party trust surface checklist, including Reddit, G2, YouTube, directories, reviews, and comparison pages
- Buyer prompt set for future manual or automated AI visibility tracking
- Page-level fix list ordered by impact

### Why People Pay

AI search visibility is harder to measure than classic rankings. Teams can rank on Google and still be absent from AI answers, while competitors get recommended through stronger entity signals, clearer content, and third-party mentions.

Most small teams do not need an enterprise GEO dashboard first. They need a quick, repeatable audit that tells them:

- whether their pages are understandable to AI systems,
- what questions their content should answer directly,
- which competitors are likely to be surfaced instead,
- what content or third-party proof is missing,
- what to fix this week.

### Input

```json
{
  "brandName": "Acme CRM",
  "website": "https://example.com",
  "category": "CRM for small agencies",
  "competitors": ["HubSpot", "Pipedrive", "Copper"],
  "buyerPrompts": [
    "best CRM for small marketing agencies",
    "HubSpot alternatives for agencies",
    "CRM with client reporting"
  ],
  "pageUrls": [
    "https://example.com/",
    "https://example.com/features",
    "https://example.com/pricing"
  ],
  "targetAudience": "small marketing agencies",
  "includeRewriteSuggestions": true
}
````

### Output

Each audited page should produce:

```json
{
  "url": "https://example.com/features",
  "brandName": "Acme CRM",
  "score": 78,
  "grade": "B",
  "entitySignals": {
    "status": "medium",
    "findings": ["Brand name appears clearly", "Category language is inconsistent"]
  },
  "answerReadiness": {
    "status": "needs_work",
    "missing": ["Direct answer paragraph", "FAQ section"]
  },
  "schemaRecommendations": ["SoftwareApplication", "FAQPage", "Organization"],
  "thirdPartyTrustGaps": ["No comparison page strategy", "No review/directory proof listed"],
  "recommendedPrompts": [
    "best CRM for small marketing agencies",
    "Acme CRM vs HubSpot for agencies"
  ],
  "fixes": [
    {
      "priority": "high",
      "action": "Add a 40-60 word direct answer near the top explaining who the product is for and when to choose it."
    }
  ]
}
```

The Actor should also write a batch summary to the key-value store under `SUMMARY`.

### MVP Scope

V1 should not claim to measure real user prompts or guaranteed AI rankings. It should audit the assets that make AI visibility more likely:

- crawlable pages,
- clear entity and category language,
- direct answers,
- structured data,
- comparison coverage,
- FAQ coverage,
- third-party proof planning.

Prompt tracking across ChatGPT, Perplexity, Gemini, Claude, or Google AI Overviews can be added later as an optional upgrade, preferably with user-provided API keys or manual result import.

### Monetization Event

Planned pay-per-event charge:

`geo-visibility-audit`

Charge one event for every page or brand asset audit written to the dataset.

### Pricing Direction

Suggested initial price:

- `$0.03` per page or brand asset audit

Target later:

- `$30-$75 / 1,000` audits
- higher price only if prompt tracking, competitor monitoring, or report export is added

### Safety / Accuracy Notes

- Do not guarantee rankings, citations, traffic, or revenue.
- Explain that AI answer systems vary by prompt, time, location, and personalization.
- Treat Reddit and third-party communities as trust surfaces, not spam targets.
- Recommend genuine participation and useful proof, not manipulative posting.
- Keep output as an audit and action plan, not legal, financial, or guaranteed marketing advice.

# Actor input Schema

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

Brand, product, or company name to audit.

## `website` (type: `string`):

Main brand website.

## `category` (type: `string`):

Market category or job-to-be-done.

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

Known competitors to compare against in prompt and content-gap recommendations.

## `buyerPrompts` (type: `array`):

Questions buyers might ask ChatGPT, Perplexity, Gemini, or AI Overviews.

## `pageUrls` (type: `array`):

Public pages to audit.

## `targetAudience` (type: `string`):

Ideal buyer or audience segment.

## `includeRewriteSuggestions` (type: `boolean`):

Generate deterministic direct-answer and FAQ suggestions.

## Actor input object example

```json
{
  "brandName": "Acme CRM",
  "website": "https://example.com",
  "category": "CRM for small agencies",
  "competitors": [
    "HubSpot",
    "Pipedrive"
  ],
  "buyerPrompts": [
    "best CRM for small marketing agencies",
    "HubSpot alternatives for agencies"
  ],
  "pageUrls": [
    "https://example.com/"
  ],
  "targetAudience": "small marketing agencies",
  "includeRewriteSuggestions": true
}
```

# 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": "Acme CRM",
    "website": "https://example.com",
    "category": "CRM for small agencies",
    "competitors": [
        "HubSpot",
        "Pipedrive"
    ],
    "buyerPrompts": [
        "best CRM for small marketing agencies",
        "HubSpot alternatives for agencies"
    ],
    "pageUrls": [
        "https://example.com/"
    ],
    "targetAudience": "small marketing agencies"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumpy_invoice/geo-visibility-audit-intelligence").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": "Acme CRM",
    "website": "https://example.com",
    "category": "CRM for small agencies",
    "competitors": [
        "HubSpot",
        "Pipedrive",
    ],
    "buyerPrompts": [
        "best CRM for small marketing agencies",
        "HubSpot alternatives for agencies",
    ],
    "pageUrls": ["https://example.com/"],
    "targetAudience": "small marketing agencies",
}

# Run the Actor and wait for it to finish
run = client.actor("jumpy_invoice/geo-visibility-audit-intelligence").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 '{
  "brandName": "Acme CRM",
  "website": "https://example.com",
  "category": "CRM for small agencies",
  "competitors": [
    "HubSpot",
    "Pipedrive"
  ],
  "buyerPrompts": [
    "best CRM for small marketing agencies",
    "HubSpot alternatives for agencies"
  ],
  "pageUrls": [
    "https://example.com/"
  ],
  "targetAudience": "small marketing agencies"
}' |
apify call jumpy_invoice/geo-visibility-audit-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GEO Visibility Audit Intelligence",
        "description": "Audit brand and page readiness for AI search visibility, citations, prompts, and answer-engine recommendations.",
        "version": "0.1",
        "x-build-id": "UUTDgZFfbbGlJY4Mh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jumpy_invoice~geo-visibility-audit-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jumpy_invoice-geo-visibility-audit-intelligence",
                "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/jumpy_invoice~geo-visibility-audit-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-jumpy_invoice-geo-visibility-audit-intelligence",
                "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/jumpy_invoice~geo-visibility-audit-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-jumpy_invoice-geo-visibility-audit-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "brandName",
                    "pageUrls"
                ],
                "properties": {
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "Brand, product, or company name to audit."
                    },
                    "website": {
                        "title": "Website",
                        "type": "string",
                        "description": "Main brand website."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Market category or job-to-be-done."
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "Known competitors to compare against in prompt and content-gap recommendations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "buyerPrompts": {
                        "title": "Buyer prompts",
                        "type": "array",
                        "description": "Questions buyers might ask ChatGPT, Perplexity, Gemini, or AI Overviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageUrls": {
                        "title": "Page URLs",
                        "type": "array",
                        "description": "Public pages to audit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "targetAudience": {
                        "title": "Target audience",
                        "type": "string",
                        "description": "Ideal buyer or audience segment."
                    },
                    "includeRewriteSuggestions": {
                        "title": "Include rewrite suggestions",
                        "type": "boolean",
                        "description": "Generate deterministic direct-answer and FAQ suggestions.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
