# Your Backlinks Are Indexed But Invisible to AI Search — I Built a Free Checker to Prove It > Source: > Published: 2026-08-28 00:31:23+00:00 A few weeks back I published [a Google Sheets tool to check backlink indexation with SerpApi](https://dev.to/seobysubham/i-built-a-google-sheets-tool-to-check-backlink-indexation-with-serpapi-and-why-i-made-it-1h0k) — 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: ``` python 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: ``` python 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: ``` python 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](https://seobysubham.com) — if you're curious about the manual, white-hat approach behind the original indexation checker too, it's all there.