How do I show up in AI search — ChatGPT, Gemini, Perplexity, Claude, Grok, DeepSeek?

The Ranking Factory asks those engines the questions your buyers ask and records who they name and which pages they cite. Where they name competitors instead of you, it works out what evidence the question needs, writes it from your own pages, videos and statements, publishes it — on your own site first where one is connected — and asks the same questions again on later runs. Being named or cited is something we observe and report with its sample size. It can take weeks, it depends on your market, and no tool controls it.

Is this SEO, or something new?

Both. Traditional SEO works to rank your pages in a list of links. Generative Engine Optimization — GEO, sometimes called AEO — works to make AI engines and Google understand your business well enough to include it in an answer, and to have pages worth citing when they do. The Ranking Factory does the second, on top of the technical audits, indexing and rank tracking it has always done. Google’s own guidance says the fundamentals are the same, which is why the site check puts crawlability and readable content above every newer idea.

Do you touch my website?

Never without you connecting it. By default everything is built off-site — Google Docs, Sheets, Slides and Blogger under your own Google account, and videos on your own YouTube channel if you switch them on — and your site is not modified. Connect WordPress, Shopify, Wix, Ghost or any webhook and pages are published on your own domain, which is the placement that matters most; webhook messages are signed, typed and keyed on a stable id, so a resend never duplicates a post, and a scheduled post that meets a busy server is tried again under that same id. Turn on review-before-publishing and every page for your site waits for your approval — and each project can hold its Google Docs, Sheets and Slides for your review as well. Some fixes only you can make — server-rendering, a CDN rule — and those are written up and handed over rather than pretended.

Where does the content you build actually end up?

A subject’s evidence goes into your own Google account, where Google’s engines read it: a guide or other document in Google Docs, with a data table in Sheets or a deck in Slides where answers were seen citing that kind of file for the subject, or where too little has been seen to tell. Videos go to your own YouTube channel if you switch them on for a campaign. These are your own facts in another place, not outside proof: each visibility run’s source count files a cited Doc, Sheet or deck, a video a campaign put on your channel, or a post on a blogspot.com blog, as published for you, never as independent, because only other people’s sites can vouch for you. They then become one page on your own domain, assembled from what was already written rather than generated a second time, because two pages of yours competing for one search helps nobody. Each project lists its own and publishes them in a click, and a part that arrives late — usually the deck — is added to the live page when it lands, except on a page an AI engine is citing: there the update waits for your approval. It will not offer a subject your own site already answers.

Is it safe for client work?

No link schemes, no spam, no shortcuts. Every action is logged in the project’s timeline; every Google file the engine creates is shared as it is made, because a file nobody can open is not evidence — unless the project holds them for your review, when each waits unshared in your own Drive until you publish it; a piece that only describes a subject instead of saying something about it is not written; when the Evidence Engine closes gaps on its own schedule, its Google documents go out at most one batch a day per campaign; the Evidence Engine does not publish a second piece on the same topic to the same place within 30 days by default; nothing is published without grounding in the business’s own material; an unsourced superlative in a page the Evidence Engine writes for your own site, or a figure its writer was not given, is cut before publishing; and nothing is announced until a stranger can open the link. Objects written before these rules can be withdrawn.

What is the Evidence Engine?

The part that does the ongoing work. It finds where AI engines and Google are missing you, asks two or three of your own AI providers what shape the answer needs, writes it from your material, publishes it, and checks on later runs whether anything changed. On Growth it runs every 6 hours, on Agency every 4, on Enterprise every 3; on Starter you press Run. Each gap whose evidence was published then shows how many of the runs checked since have cited it, with the engines — an association, not proof that the page caused it.

How much of this is automatic — what do I actually have to do?

You add your business, correct what the crawl proposes about it, add an AI key, and connect Google and — ideally — your own site. From then on the engine measures, finds gaps, writes, publishes and re-measures on its schedule, and the dashboard separates what is running from what needs you. The things only you can do — a site edit, a product nothing of yours explains, a placement on an independent site, a reply on a forum — arrive as a short list with a way to end each item.

Will this get me cited on Reddit, Wikipedia or review sites?

Not directly, and be wary of anything that claims otherwise. Most AI citations come from third-party sources — forums, Wikipedia, review platforms, industry press — and no tool can honestly manufacture those. What this does is make you the kind of business those answers can draw on, show you which sites the engines actually cite for your market so you can go and earn a place in them, and find the live discussions already asking what you answer. It does not post to Reddit or edit Wikipedia on your behalf; there is no code path that could.

Why did my visibility change when I haven’t done anything?

Because AI answers are not deterministic — ask the same question twice and you can get different businesses named. That is a property of the engines, not a fault in the measurement. It is why we report rates with a confidence range and the sample size behind them, why we treat trends across runs as the signal rather than any single run, and why adding a new engine starts a fresh trend line instead of quietly changing your history. Ask each prompt 3 or 5 times in one run and we report stability — whether repeats agreed — separately from the rate, and list the exact prompts that changed their answer.

Do I need my own AI key, and what does it cost?

Yes, for the parts that ask the AI engines about you — those run on your key and spend your credit, which is why nothing is asked unannounced. Each project is measured once a week by default, and before its first run we email you what it will ask, on which engines and about what it will cost; the first run is no sooner than a day after that email, and “Don’t measure this project” switches it off. With billing on, Gemini’s first 5,000 searches a month are free — far more than weekly measurement uses. Google AI Overview checks run on your own DataForSEO credit, only for searches you chose, inside a monthly budget you can lower. Having the ChatGPT and Gemini apps, or Google AI Mode, asked your tracked prompts uses the same DataForSEO credit, outside that budget: about $0.0012 a question, with each one’s monthly estimate shown before you switch it on. Two optional readings also use your key, and only if you turn them on when you set up a project or later in Settings: a before-reading for each new gap (up to 8 calls with 4 engines, at most 5 a day per project) and a passage check on each page for your site (one call per section, at most 12 a page). The site audits need no key at all: they read your site directly, so you see real findings before spending anything. Each engine you add is another engine you can see into, not a more accurate reading of the same one.

What can’t you fix for me?

Anything that lives on your own website and needs a developer. The most common are content that only appears after JavaScript runs (Google renders it, most AI crawlers don’t, so they see an empty page) and a CDN blocking AI crawlers even though your robots.txt allows them. We detect both and tell you exactly what to change — we just don’t pretend there is a button for it. The site check also says what it does not measure — Core Web Vitals, how the page behaves on a phone, links from other sites — and shows those as not measured rather than as a pass. Everything we hand you is labelled: we fix it, paste this, or needs a developer.

How accurate are the numbers?

As accurate as the sample allows, and we show you the sample. A run’s named, cited and recommended rates each carry a 95% confidence range and the number of prompt-and-engine pairs behind them; a wide range means few samples, not a poor result. Under twenty questions a first run calls itself a first look and says what would make it a baseline. Every figure says which engine API it was measured on — that is not the same as Google AI Overviews or the ChatGPT app, and we measure the first of those separately. The ChatGPT and Gemini apps themselves, and Google AI Mode, are asked only for the tracked prompts you switch them on for, each on its own line and never part of the score. Anything we could not measure is shown as unmeasured, never as a zero. The whole method is written up at /how-we-measure, including what the numbers do not claim.

Does it publish without asking me?

By default, yes — that is the point of an engine — and it tells you exactly what went out, item by item, with links, in the weekly report and on the project page. If you would rather approve first, there are two switches. Turn on “review before publishing” in Settings and every page written for your own site waits for you, and you are told the moment one is waiting. And each project can hold its Google Docs, Sheets and Slides for your review: each is written into your own Google Drive but not shared, linked or counted until you press Publish — one at a time, a chosen group at once, or a few a day over the days you choose — and Discard leaves it private. Either way nothing is published without grounding in your real content, no unsourced superlative survives the claim check on a page the Evidence Engine writes for your own site, and nothing is announced until we have checked a stranger can open the link. And any Google file a campaign made can be taken down again — one, a chosen set or the whole campaign — unpublished, its link sharing removed and moved to Drive’s bin.

Which AI engines does it measure?

ChatGPT, Gemini, Perplexity, Claude, Grok and DeepSeek — whichever you connect, using your own keys — plus Google’s AI Overviews as a separate surface, read from a live results page on your own DataForSEO credit, and Google’s own AI Overview and AI Mode impressions imported from a Search Console export. The ChatGPT and Gemini apps themselves, and Google AI Mode, can also be asked your tracked prompts, through DataForSEO on your own DataForSEO account from your project’s location, each on its own line and never in the score. Bing Webmaster Tools can be connected too, read only, for whether Bing has verified your site and indexed the pages we published: that is Bing’s index, not an AI engine, and it is never in the score. Where an engine can search the web as it answers (Gemini with Google Search grounding, Perplexity, OpenAI’s search tool on a current model, Claude with Anthropic’s web search tool, and Grok with xAI’s web search tool) we say so and report what it read; where it can only answer from training, the result is labelled as such. Adding an engine widens the picture; it does not sharpen it.

Can my own AI tools read my account?

Yes — the account answers an AI agent directly over MCP, read and write, on every plan including Starter. Mint a scoped key in Settings and point Claude Code, Claude Desktop, the Claude API or your own tooling at it, or have Claude connect by signing in instead; either way you choose whether it reads every project or one. Eleven read tools cover your visibility runs and per-topic measurement, the sites engines cited, your gap list, the published-evidence ledger, answerability, what is waiting for your approval and your entity — always available. Every rate arrives with its sample size, and no agent can publish, approve or change anything through it unless you tick “Let it make changes” when you make the key or the connection — off by default, audited, and rate-limited once it is on, with every change it makes listed in Settings.

What happens when the trial ends?

The 14-day trial is on the Growth monthly plan and becomes a subscription at $129 a month unless you cancel first. If a trial ends unpaid or a subscription lapses, the account goes read-only: you can still sign in and see every project, measurement and published item, but nothing new runs until you subscribe again. Nothing is deleted straight away; an account left read-only for 12 months can be deleted, with an email at least 30 days before.

How quickly will I see results?

Measurement is immediate: the site check needs only your address, and the first visibility run happens as soon as you have confirmed what you do and added a key. Evidence starts publishing from the first cycle. How fast any of that turns into being named or cited depends on your market and on retrieval nobody controls; we show you what is happening as it happens — published, crawled, indexed, cited — and we do not promise positions, citations or timescales.

Developers

The Ranking Factory is reached by agents in three ways: a read/write MCP server over one customer account, a free MCP server that needs no sign-in, and the same free site check as a plain REST endpoint with an OpenAPI document. Everything below is what those servers answer today.

The servers

Account server

com.therankingfactory/mcp

https://therankingfactory.com/api/mcp

One customer account: visibility runs, evidence gaps, cited sources, published evidence and the entity. Reads from the moment a credential connects; writes only with the write scope. Sign in with OAuth or send an agent key.

Free check server

com.therankingfactory/site-check

https://therankingfactory.com/api/mcp/check

No account and no sign-in. One tool, check_site, which changes nothing, asks no AI engine and stores nothing.

Free check REST API

OpenAPI 3.1

GET https://therankingfactory.com/api/public/site-check?url=

The same check as check_site for a client that does not speak MCP, with the same answer.

Both MCP servers speak JSON-RPC 2.0 over HTTP POST (streamable HTTP, no server-push stream: a GET answers 405). They speak MCP 2026-07-28 per request, and 2025-11-25 or 2025-06-18 through initialize. A request body over 64 KB is refused with 413.

Connect

Add https://therankingfactory.com/api/mcp to a client that supports MCP authorization. An unauthenticated request gets 401 with WWW-Authenticate: Bearer resource_metadata="…" naming the protected-resource metadata; the client follows it to the authorization server. Authorization code with PKCE (S256) and theresource parameter; client identity by a Client ID Metadata Document or registration atPOST /api/oauth/register. Access tokens (rfa_) last one hour; refresh tokens (rfr_) last 30 days and rotate on every use. The customer chooses every project or one.

An agent key

For any MCP client. The customer creates a key under Settings → Agent access, chooses what it may read, and leaves or ticks “Let it make changes” (unticked by default). It is shown once; only its hash is kept. Send it on every request as Authorization: Bearer rft_…. A key sees every project in the account.

Both credentials work on every plan, Starter included, and in the 14-day trial, and only at the MCP endpoint: neither opens anything else on this API. The free check server takes no credential at all.

curl -s https://therankingfactory.com/api/mcp \
  -H "Authorization: Bearer rft_..." \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"example","version":"1.0"}}}'

curl -s https://therankingfactory.com/api/mcp \
  -H "Authorization: Bearer rft_..." \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

curl -s https://therankingfactory.com/api/mcp/check \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"check_site","arguments":{"url":"example.com"}}}'

Step-by-step connection guide |What people ask it

Tools

tools/list shows a credential only the tools its scopes unlock, and every tool carries the MCP annotations readOnlyHint, destructiveHint, idempotentHint andopenWorldHint. Every read tool answers across all of the account's projects unlessproject (a domain or a project's name) narrows it, and rates come with their sample sizes.

Account server: 11 read tools

Read tools
Tool	Scope	What it does
`get_visibility_summary`	visibility:read	Recent AI-visibility runs per engine, model and surface: answers back, and how many named, cited or recommended the business, with their denominators.
`get_topic_visibility`	visibility:read	Per-topic measurement history: runs that measured each topic, runs that named the business, and runs that named it unprompted.
`list_cited_sources`	visibility:read	The sites AI answers actually cited, grouped by site and kind, with declared versus extracted citations and naming rates.
`get_gaps`	gaps:read	The evidence-gap list: counts by status, the open items with ids, and citations since each gap's evidence was published.
`get_published_evidence`	evidence:read	The published-evidence ledger, newest first: what was published where and when, and which engine first cited it.
`get_topic_evidence_pool`	evidence:read	The outside sources a writer may cite for one subject, each fetched and checked, with the refused ones listed as such.
`get_answerability`	evidence:read	Whether pages published to the customer's own site answer the questions they are shown for.
`get_entity`	entity:read	Who the business is, as asserted: name, type, what it does, where, its main topic and its sameAs links.
`get_claims`	entity:read	The facts asserted about the business and its stated relationships, with their confidence.
`get_sources`	entity:read	The sources behind the claims, each classed Owned, Controlled, Independent or Unattributable.
`list_waiting`	evidence:read	What is written and waiting for the owner's approval, with whether approve_publish can send each item.

Account server: 6 write tools (need `write` as well)

Write tools
Tool	Scope	What it does
`update_entity`	entity:read	Corrects one project's entity: description, main topic, location, tags and sameAs links. Only the fields passed change.
`confirm_product`	entity:read	Says what one of the business's own named products is, from the owner's words or a page on its own site.
`close_gap`	gaps:read	Asks the Evidence Engine to work one open gap now, with the same refusals as "Close it now" in the app.
`approve_publish`	evidence:read	Approves one item from list_waiting, by id and version, on the owner's instruction. Publishes; cannot be undone from here.
`schedule_held_release`	evidence:read	Plans spreading held Google files over N days; starts the schedule only with start: true, on the owner's word.
`run_visibility_now`	visibility:read	Starts a visibility run for one project from its saved watchlist, on the account's own AI keys.

Each write calls the same code as the app's own button, with the same refusals, names one project by its exact domain, and is recorded for the account owner under Settings → Agent access.

Free check server: 1 tool

Free check server tool
Tool	Scope	What it does
`check_site`	none	Checks one public website's readiness for AI search, free and without an account: finding titles and tiers, every check made, and a link to the full report.

Scopes

visibility:readAI-visibility measurements: runs, per-engine rates, per-topic history.
gaps:readThe evidence-gap list: open, in flight, closed, abandoned, and waiting on a person.
evidence:readThe published-evidence ledger: what was published where, when, and what AI answers cited.
entity:readThe business itself: its identity, the facts asserted about it, and the sources behind them.
recommendations:readThe project reviewer's recommendations, where the reviewer is switched on for the account. Reading only.
writeMake changes through the six write tools. Never granted by default: a box that starts unticked on every connection and key.

A write tool called without write answers 403 withWWW-Authenticate: Bearer error="insufficient_scope" and a scope naming the scopes the credential holds plus the ones the tool needs.

Limits

Writes: 30 write attempts an hour per credential - done, refused or failed alike, in a sliding hour. Reads are not limited.
Free check: 60 checks an hour in all, shared by check_site and the REST endpoint, and 20 checks of one site a day.

Every call to a write tool carries the IETF rate-limit headers (draft-ietf-httpapi-ratelimit-headers):RateLimit-Policy with the quota and the window in seconds, and RateLimit with what is left and the seconds until the oldest counted attempt leaves the hour. A call the ceiling refused also carriesRetry-After. The refusal itself is a tool error inside a 200, as every write refusal is.

RateLimit-Policy: "writes";q=30;w=3600
RateLimit: "writes";r=0;t=1260
Retry-After: 1260

Errors

Every error body is JSON.

No credential, or one that is unknown, expired or revoked (account server)

HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer resource_metadata="https://therankingfactory.com/.well-known/oauth-protected-resource/api/mcp", scope="…"

{"error":"This endpoint needs a credential: sign in from your AI client (OAuth), or send an agent key as \"Authorization: Bearer rft_…\". How to get either is described at https://therankingfactory.com/.well-known/auth.md"}

A write tool without the write scope

HTTP/1.1 403 Forbidden
WWW-Authenticate: Bearer error="insufficient_scope", resource_metadata="…", scope="…", error_description="…"

{"jsonrpc":"2.0","id":7,"error":{"code":-32001,"message":"close_gap changes the account, and this credential does not hold \"write\". …"}}

A refused or failed tool call

{"jsonrpc":"2.0","id":8,"result":{"content":[{"type":"text","text":"Refused: … Nothing was changed."}],"isError":true}}

Protocol errors are JSON-RPC errors: -32700 the body is not JSON, -32600 not a single request object (batches are not supported), -32601 unknown method, -32602 unknown tool. A 2026-07-28 request that is malformed, mismatched or names an unsupported version is answered 400, and an unknown method 404, each with a JSON-RPC error body.

The REST check

HTTP/1.1 429 Too Many Requests
Retry-After: 2400

{"code":"site_limit","message":"That site has been checked many times today. …"}

Codes: url_required and invalid_url and address_refused (400),busy and site_limit (429, with Retry-After), check_failed (502). The app's own API, behind its login, answers a missing or expired session with 401{"error":"unauthorized","message":"…"} and a refused one with 403{"error":"forbidden","message":"…"}; it is not a public API.

REST and OpenAPI

GET https://therankingfactory.com/api/public/site-check?url=example.com runs the free check and answers with the site checked, when, three scores (SEO, GEO and agent readiness, each 0-100 or null), each finding's tier and title (Blocker first), every check made with its result, and fullReport: where the person can have the full report emailed. No key, open to any origin. It is described by an OpenAPI 3.1 document, the only REST API we publish; the rest of our API serves our own app and is not documented for outside use.

curl -s "https://therankingfactory.com/api/public/site-check?url=example.com"

https://therankingfactory.com/openapi/site-check.json

Machine-readable files

/.well-known/mcp/server-card.json
The account server described with its full tool and scope list, generated from the catalogue the server runs on.
/api/mcp/server-card
The account server's MCP Server Card: name, version, remote and supported protocol versions.
/api/mcp/check/server-card
The free check server's MCP Server Card.
/.well-known/auth.md
How an agent authenticates, in prose (also at /auth.md).
/.well-known/oauth-protected-resource/api/mcp
OAuth protected-resource metadata (RFC 9728). Its resource is the account server's URL.
/.well-known/oauth-authorization-server
OAuth authorization-server metadata (RFC 8414).
/openapi/site-check.json
OpenAPI 3.1 for the free site check's REST endpoint - the only REST API we publish (also at /openapi.json).
/.well-known/api-catalog
The API catalog (RFC 9727): one item per API, each with where it is described and documented.
/.well-known/ard.json
Agentic Resource Discovery catalog listing both MCP servers (the same entries at /.well-known/ai-catalog.json).
/llms.txt
What the product is, for AI systems summarising it (the same text at /llms-full.txt).

Every response also carries an RFC 8288 Link header naming llms.txt, the sitemap and the API catalog. Questions, or an interface you need that is not here: [email protected].