# AI Citation Checker: Is My Page Cited by ChatGPT & Perplexity? (`highbrow_fame/ai-page-citation-checker`) Actor

Page citation checker: is your page cited by ChatGPT, Perplexity or Gemini? Paste URLs, get buyer questions written from each page, whether your page and your site are cited and at which position, plus the competitor sites cited instead. $0.12 per URL, free sample, no API key.

- **URL**: https://apify.com/highbrow_fame/ai-page-citation-checker.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** SEO tools, AI, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $84.00 / 1,000 page checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Citation Checker - Is My Page Cited by Perplexity & Gemini

**$0.12 per page checked: 10 pages cost $1.20, and the free sample run costs no page fee.**

You published a page. A buyer asks an AI assistant a question that your page answers. Does the assistant cite your page, cite another page of your site, or send the buyer to a competitor? This Actor answers that for every page you give it.

Paste page addresses. For each one the Actor reads the title, description and headings, **writes the questions a buyer would ask**, asks Perplexity, Google Gemini and ChatGPT (all with live web search), and checks the cited sources: **is your exact page there, is your site there, at which position, and which websites were cited instead.**

No question list needed, no API key needed.

**Try it in one minute:**

1. Press **Start**. The prefilled input checks two public pages with 2 questions each on Perplexity and Gemini.
2. Open the **Output** tab: one row per page with the citation rate, the best position and the competitors cited instead.
3. Replace the prefilled addresses with your own pages. Tick **Free sample run** first if you want to see real output on your first page before paying.

### More AI visibility tools from highbrow_fame

| Tool | Question it answers | Price |
| --- | --- | --- |
| [AI Brand Monitor](https://apify.com/highbrow_fame/ai-search-visibility-tracker) | Is my brand cited by ChatGPT, Perplexity and Gemini? | $0.05 per answer; [full audit $4.80](https://apify.com/highbrow_fame/ai-search-visibility-tracker/examples/full-ai-visibility-audit-5-dollars) |
| [AI share of voice](https://apify.com/highbrow_fame/ai-brand-share-of-voice) | Which brands do ChatGPT, Perplexity and Gemini name in my category, and how often is mine named vs competitors? | $0.08 per prompt |
| [AI Overview citation checker](https://apify.com/highbrow_fame/ai-overview-citation-checker) | Which sites does Google AI Overview cite for my keywords? | $0.03 per keyword |
| [Shopify AI Readiness Audit](https://apify.com/highbrow_fame/shopify-ai-readiness-audit) | Is my Shopify catalog ready for AI shopping assistants? | $0.01 per store |

### What you get

One dataset row per page:

| Field | Meaning |
| --- | --- |
| `url`, `pageTitle`, `h1`, `metaDescription` | the page and what was read from it |
| `promptsTested` | the questions that were asked (`promptSource`: `model`, `template` or `custom`) |
| `citedBy` | per engine, the questions whose answer cited **exactly this page** |
| `siteCitedBy` | per engine, the questions whose answer cited **any page of your site** |
| `citationRate`, `siteCitationRate` | share of all analysed answers that cite the page / the site (0-1) |
| `bestPosition`, `bestSitePosition` | best place in an answer's source list (1 = first); `null` if never cited |
| `competitorUrlsCitedInstead` | up to 5 other websites cited most often: domain, top URL, citations, engines |
| `answersAnalysed`, `enginesUsed`, `engineErrors` | how many answers the rates rest on |
| `checkedAt`, `status`, `error` | when, and `OK`, `FAILED` (not charged) or `NOT_PROCESSED` |

The key-value store record `OUTPUT` holds a run summary (pages checked, failed, cited) next to all rows.

#### Sample output

From a real run on Perplexity and Gemini with 2 of our own questions for the page (4 answers). Your numbers will differ: that is the point of measuring.

```json
{
  "url": "https://www.atlassian.com/agile/project-management",
  "pageTitle": "What is Agile Project Management? | Atlassian",
  "promptsTested": ["what is agile project management?", "explain agile project management"],
  "promptSource": "custom",
  "answersAnalysed": 4,
  "citedBy": { "perplexity-agent": ["what is agile project management?"] },
  "siteCitedBy": {
    "gemini": ["what is agile project management?", "explain agile project management"],
    "perplexity-agent": ["what is agile project management?", "explain agile project management"]
  },
  "citationRate": 0.25,
  "siteCitationRate": 1,
  "bestPosition": 2,
  "competitorUrlsCitedInstead": [
    { "domain": "apm.org.uk", "url": "https://apm.org.uk/", "citations": 3, "engines": ["gemini", "perplexity-agent"] },
    { "domain": "adobe.com", "url": "https://business.adobe.com/blog/basics/agile-manifesto", "citations": 2, "engines": ["perplexity-agent"] }
  ],
  "status": "OK"
}
```

Read it like this: the site was cited in every answer, the exact page in one of four (Perplexity, second source), and `competitorUrlsCitedInstead` shows who else was cited, so you know whose page to study.

### Input

- **Pages to check** (required): full addresses of your own pages, up to 100 per run.
- **Questions per page**: 1-5, default 3. The Actor writes them from the page; they never contain your brand name, so a citation means the engine found you on merit.
- **AI engines**: Perplexity and Gemini on our keys; ChatGPT with web search is included in a capped form (see Limits). Add your own OpenAI key to run ChatGPT on every question.
- **Market (country)** and **Language**: which market the buyer is in and which language the questions and answers use.
- **Repeats per question and engine**: 1-3, default 1. Questions x repeats per page is capped at 5.
- **Your own questions per page**: optional JSON, for example `{"https://example.com/blog/post": ["how do I compare crm tools?"]}`. Also lets you check a page that cannot be read.
- **Free sample run**: first page only, 2 questions, Perplexity only, no page fee.

### How your pages are read

Each page is requested once with the user agent `AICitationCheckerBot/0.1 (+https://apify.com/highbrow_fame/ai-page-citation-checker)`. The Actor reads `robots.txt` first and does not fetch a page that it disallows. It does not use proxies, does not retry a refusal, and does not try to get around a bot check or login: such a page is reported as `FAILED` with the reason, and is not charged. Only the title, meta description and headings are used.

### Price

**$0.12 per page checked** (pay per event). A page counts as checked when its questions were written or supplied, at least one engine answered, and the citations were analysed; questions, engines and repeats do not change the price. A page that cannot be read, that no engine answers, or that the run's maximum charge had no room for is not charged. Checking 50 pages costs $6.00. The free sample run charges no page fee; Apify's small run-start fee applies to every run on the platform.

### Honest limits

- **It measures what the engines say today, from a small sample.** AI answers vary between requests and between weeks. 3 questions on 3 engines is a first reading, not a precise percentage; run it monthly or use more questions to see movement.
- **Gemini names sources by site only.** Google hides the real address behind a redirect, so a Gemini citation can prove that your site was cited but not which page. For Gemini, read `siteCitedBy`; `citedBy` for Gemini only fires when your page is the home page. Perplexity and ChatGPT cite exact addresses.
- **The questions are a guess at your buyers' words.** They are written by a language model from your page. If the model is unavailable the Actor builds simpler questions from the page topic and says so in `promptSource`. For questions you know matter, use **Your own questions per page**.
- **ChatGPT is capped on our key.** ChatGPT with web search costs about three times more to run than the other engines, so on our key it makes 1 call, on the first question, for the first 10 pages of a run (2 pages on a free Apify plan). Add your own OpenAI key and it runs on every question and repeat, on your own OpenAI bill.
- **A page that needs JavaScript to show its title or headings** may be unreadable to us; give your own questions for it.
- **Matching** treats `www`, `http`/`https`, query strings, fragments and a trailing slash as the same page. A different path is a different page.
- **Not affiliated with** or endorsed by Perplexity, Google or OpenAI.

### FAQ

**Why is my page not cited although my site is?** The engine found your site useful but preferred another page of it, or a competitor's page for that exact question. `competitorUrlsCitedInstead` shows who won, so you can compare their page with yours.

**Can I run it on a schedule?** Yes. Use an Apify schedule and compare `citationRate` from run to run, or read the dataset through the API.

**Can I check a competitor's page?** The Actor is meant for pages you own. It will check any public page that robots.txt allows, but the question writer is told not to use the site's name, which suits your own pages best.

If this Actor was useful, an honest review on its Store page helps other people find and judge it.

# Actor input Schema

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

Full web addresses of your own pages, one per line (up to 100), for example https://example.com/blog/my-post. Each page is read once, politely: robots.txt is respected and nothing is bypassed. A page that cannot be read is reported and not charged.

## `promptsPerPage` (type: `integer`):

How many buyer questions to write from each page and ask the AI engines (1-5). More questions give a steadier citation rate. The price is per page, not per question.

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

Which engines answer the questions. Perplexity and Gemini (Google Search grounded) run on our keys. ChatGPT with web search costs far more to run, so on our key it gets 1 call, on the first question, for the first 10 pages of a run (2 pages on a free Apify plan); add your own OpenAI key below to run it on every question.

## `country` (type: `string`):

Two-letter country code of the market your buyers are in, for example us, gb, de, au. For anything except us it is mentioned to the question writer, so questions and answers fit that market.

## `language` (type: `string`):

Language of the questions and of the AI answers (two-letter code).

## `samples` (type: `integer`):

How often each question is asked on each engine (1-3). AI answers change from one request to the next, so a repeat smooths out luck. Questions x repeats per page is capped at 5, so with 3 questions the Actor uses at most 1 repeat.

## `sampleRun` (type: `boolean`):

Checks only the first page, with 2 questions, 1 repeat, on Perplexity only, and charges no page fee, so you can see real output before paying. The platform run-start fee still applies.

## `customPrompts` (type: `object`):

Optional. Questions you want asked instead of the written ones, as JSON: the page address as key and a list of questions as value, for example {"https://example.com/blog/my-post": \["how do I compare crm tools?"]}. Pages with their own questions are also checked when the page itself cannot be read.

## `openaiApiKey` (type: `string`):

Only for ChatGPT. With your own key ChatGPT runs on every question and repeat, on your OpenAI bill (about $0.012 per call). Without it, ChatGPT is capped as described under AI engines.

## `maxConcurrency` (type: `integer`):

How many pages are processed at the same time (1-5). Lower it if you see rate-limit warnings.

## Actor input object example

```json
{
  "pageUrls": [
    "https://www.atlassian.com/agile/project-management",
    "https://www.notion.com/product/projects"
  ],
  "promptsPerPage": 2,
  "engines": [
    "perplexity-agent",
    "gemini"
  ],
  "country": "us",
  "language": "en",
  "samples": 1,
  "sampleRun": false,
  "customPrompts": {},
  "maxConcurrency": 3
}
```

# Actor output Schema

## `pages` (type: `string`):

One row per page: the questions asked, which engines cited the page or its site, citation rates, best position and the competitors cited instead.

## `pagesCsv` (type: `string`):

The same rows as CSV, for a spreadsheet.

## `fullReport` (type: `string`):

OUTPUT record of the key-value store: pages checked, failed and cited, engines used, and every page row.

# 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 = {
    "pageUrls": [
        "https://www.atlassian.com/agile/project-management",
        "https://www.notion.com/product/projects"
    ],
    "promptsPerPage": 2,
    "engines": [
        "perplexity-agent",
        "gemini"
    ],
    "country": "us",
    "samples": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/ai-page-citation-checker").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 = {
    "pageUrls": [
        "https://www.atlassian.com/agile/project-management",
        "https://www.notion.com/product/projects",
    ],
    "promptsPerPage": 2,
    "engines": [
        "perplexity-agent",
        "gemini",
    ],
    "country": "us",
    "samples": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/ai-page-citation-checker").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 '{
  "pageUrls": [
    "https://www.atlassian.com/agile/project-management",
    "https://www.notion.com/product/projects"
  ],
  "promptsPerPage": 2,
  "engines": [
    "perplexity-agent",
    "gemini"
  ],
  "country": "us",
  "samples": 1
}' |
apify call highbrow_fame/ai-page-citation-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,highbrow_fame/ai-page-citation-checker"
        }
    }
}
```

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/mhb5gT8wJsHC6yQeg/builds/JmVZl80w2LR90dG4r/openapi.json