A few weeks back I published a Google Sheets tool to check backlink indexation with SerpApi — a simple, manual-only script that tells you whether a backlink has actually been picked up by Google, instead of guessing.
It worked well. One backlink I was tracking got indexed by Google in under 72 hours. Good news, right?
Then, out of curiosity, I opened ChatGPT and asked it about the exact page that backlink pointed to.
It had no idea the page existed.
Not "I don't have real-time data." Not a vague guess. It simply didn't know the content was there — despite Google indexing it days earlier.
That gap is the entire premise of this post: being indexed by Google and being visible to AI search are two completely different things, and almost nobody is measuring the second one.
So I extended my original checker to test for both.
For over a decade, indexation was the finish line. If Google crawled your page and added it to the index, you were in the game — rankings were just a matter of time and optimization from there.
That assumption is breaking down.
A growing share of search now happens inside AI systems — ChatGPT, Perplexity, and Google's own AI Overviews — that don't work like the traditional index. They don't list ten blue links; they synthesize an answer from a handful of sources they trust enough to cite. A page can be perfectly indexed and still never make it into that shortlist.
For anyone doing SEO or link building, that means a new failure mode nobody's watching for: a backlink that "worked" by every traditional metric, but contributes zero visibility where a growing number of searches actually happen.
I wanted a way to see that gap directly, on my own sites, without relying on vibes.
The original tool answered one question per backlink: is this indexed?
The updated version answers three:
site:
query)Each backlink row in the Google Sheet ends up with three simple signals instead of one, plus a combined score so I can sort and prioritize at a glance.
Same stack as before: Python, the SerpApi library, and Google Sheets as the interface — no dashboard, no database, nothing to maintain.
This part is unchanged from the original tool — a straightforward site:
search through SerpApi to confirm the URL is indexed:
import requests
def check_indexation(url, serpapi_key):
params = {
"engine": "google",
"q": f"site:{url}",
"api_key": serpapi_key
}
response = requests.get("https://serpapi.com/search", params=params)
results = response.json()
return bool(results.get("organic_results"))
SerpApi's Google engine returns an ai_overview
block when one is present for a query. I check whether my domain shows up anywhere inside its sources:
def check_ai_overview(keyword, target_domain, serpapi_key):
params = {
"engine": "google",
"q": keyword,
"api_key": serpapi_key
}
response = requests.get("https://serpapi.com/search", params=params)
results = response.json()
ai_overview = results.get("ai_overview", {})
sources = ai_overview.get("references", [])
cited = any(target_domain in src.get("link", "") for src in sources)
return {
"has_ai_overview": bool(ai_overview),
"domain_cited": cited
}
If there's no AI Overview at all for that keyword yet, I record that too — it's a useful signal on its own.
This one is more experimental, and I want to be upfront about that. I send a small, consistent prompt to the OpenAI API asking whether the model has knowledge of the page or domain, and log the raw response for manual review rather than trying to auto-parse a yes/no:
from openai import OpenAI
client = OpenAI(api_key="YOUR_OPENAI_KEY")
def check_llm_recognition(url, domain):
prompt = (
f"Are you aware of the website or page at {url} "
f"(domain: {domain})? If so, briefly describe what it's about. "
f"If you have no knowledge of it, say so directly."
)
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": prompt}],
max_tokens=150
)
return response.choices[0].message.content
I run the same prompt structure against Perplexity's API too, since its answers are grounded in live search rather than training data alone — it tells me something different: not "does the model remember this," but "would this page surface in a real-time AI search right now."
Each backlink gets logged as a row with:
| Backlink URL | Indexed? | AI Overview exists? | Domain cited in Overview? | LLM recognizes page? | Notes | |---|
I don't collapse this into a single fake "score out of 100" — SEO tools do that too often and it hides more than it reveals. Instead I flag any row where Indexed = Yes but both AI columns are No. Those are the interesting rows. That's the actual gap.
Out of the backlinks I re-checked from my last batch:
The AI Overview number was the useful one. It's the closest thing to a real-time "does AI search actually see this" signal available right now, and it's a much smaller percentage than the indexation rate. That gap is exactly what I was trying to surface.
Same reasoning as the original tool, and it applies even more here:
Manual-only isn't a limitation here — it's the correct way to use a signal that's still this noisy.
A few things worth being upfront about, since overselling this would defeat the point of writing it:
If you're building something similar, treat every AI-visibility signal as directional, not authoritative.
The full script (indexation + AI Overview + LLM recognition check) is a single Python file plus a Google Sheet template — no server, no signup, nothing to host. If you want to run it on your own backlinks, I'm happy to share the setup in the comments or a follow-up post.
If you've noticed the same indexed-but-invisible gap on your own sites, I'd genuinely like to hear what you found — drop it below.
I write and build tools like this as part of my link-building work at SEO by Subham — if you're curious about the manual, white-hat approach behind the original indexation checker too, it's all there.