Enter a URL
Index Check (via Google CSE) answers one narrow, practical question: is a specific URL currently retrievable through Google's search results? It does this by querying the Google Custom Search Engine (CSE, now officially called Programmable Search Engine) API for the exact URL you submit, then inspecting whether that URL — or a page matching it closely — comes back in the response. If it does, the page is treated as indexed. If the API returns nothing matching that address, the tool reports it as not found in the index (or at least not found through this particular lookup method, which is an important distinction covered further down).
This is not the same thing as checking whether a page exists, whether it loads correctly, or whether it ranks for any particular keyword. A page can be perfectly live, fast, and error-free and still fail this check if Google hasn't crawled it yet, has crawled it but chosen not to index it, or has indexed it under a different canonical URL than the one you typed in.
To use this tool well, it helps to understand the three separate stages a page goes through before it can show up in search results, because a "not indexed" result can mean the page is stuck at any one of them.
Google has to first find out a URL exists. This usually happens through internal links, an XML sitemap, an external link from another site, or a manual submission through Search Console. A brand-new page with no links pointing to it and no sitemap entry may simply be undiscovered.
Once discovered, Googlebot has to actually request the page. Crawling can be delayed or skipped entirely because of a limited crawl budget, a robots.txt disallow rule, server errors, extremely slow response times, or a page that's buried too many clicks deep in the site structure.
Crawling does not guarantee indexing. Google renders the page, evaluates its content, and decides whether it's worth adding to the index. Thin content, duplicate content, a noindex meta tag or X-Robots-Tag header, a canonical tag pointing elsewhere, or a quality assessment that the page adds little value can all result in "crawled — currently not indexed," which is one of the most common statuses webmasters see in Search Console and one of the most confusing for anyone relying only on a simple yes/no index check.
A page can therefore be discovered but not crawled, crawled but not indexed, or indexed today and dropped tomorrow. The index check tool only reports the final outcome — indexed or not — not which stage the page is stuck at, which is why it works best as a first alarm rather than a full diagnosis.
Before Google restricted scraping of its main results pages, the simplest way to check indexation was to type site:example.com/page directly into Google search and see if anything came back. That still works manually in a browser, but it's unreliable to automate: Google actively blocks automated queries against the main search interface, rate-limits aggressively, and the site: operator itself has become noticeably less precise over the past few years — Google has said openly that site: is a legacy diagnostic and doesn't guarantee a complete or fully accurate picture of what's indexed.
Programmable Search Engine (CSE) offers a sanctioned, rate-limited API alternative. A CSE can be configured to search either a defined list of sites or "the entire web," and when queried through Google's official JSON API, it returns structured, machine-readable results instead of raw HTML that has to be scraped and parsed. This tool sends your URL as a query to a CSE configured for full-web search, then checks the returned result set for an exact or near-exact URL match. That match (or lack of one) becomes the indexed/not-indexed verdict you see.
The practical upside is a query method that doesn't rely on scraping Google's results page and won't get your IP blocked the way repeated manual site: queries eventually will. The tradeoff is that a CSE's result set is not always a perfect mirror of Google's full main index — it's built on top of it, but caching behavior, result freshness, and edge-case filtering can differ slightly from what you'd see doing the same search by hand.
A page that isn't indexed cannot rank, cannot receive organic traffic, and cannot pass link equity through internal links in any meaningful way from a search-visibility standpoint. Indexation is the floor requirement before any SEO work — content quality, backlinks, page speed — even starts to matter. Knowing quickly when a page has failed to get indexed, or has silently dropped out of the index, lets you fix the root cause before it costs weeks of lost visibility.
After publishing, most sites don't get instant indexing. Checking a day or two later tells you whether to just wait or whether something (a noindex tag left over from staging, a blocked resource, a sitemap that wasn't updated) needs attention.
Large product catalogs frequently have thousands of URLs that never get indexed because of duplicate content, thin descriptions, or crawl budget spread too thin. Spot-checking product URLs across categories gives a fast read on where the problem is concentrated.
When organic traffic falls off a cliff, one of the first diagnostic steps is confirming whether the affected pages are still indexed at all, versus indexed but ranking lower. Those are two very different problems with different fixes.
Search Console only shows data for properties you've verified. If you need to check indexation status for a URL on a site you don't own — a guest post, a directory listing, a scraped copy of your content — an external index checker is the only practical option.
| Method | Requires site ownership/login | Best for | Main limitation |
|---|---|---|---|
| Index Check via Google CSE (this tool) | No | Quick checks on any URL, including sites you don't control | Subject to CSE result quirks and API query limits; not a full diagnostic |
| Google Search Console — URL Inspection | Yes (verified property) | Definitive status straight from Google, including why a page isn't indexed | Only works for properties you've verified ownership of |
| Manual "site:url" search in Google | No | One-off spot checks | Not reliable at scale; Google itself warns it's not a precise count |
| XML sitemap coverage report | Yes (Search Console) | Understanding indexation across an entire submitted sitemap | Reports at the sitemap level, slower to reflect single-URL changes |
| Third-party log file analysis | Yes (server access) | Confirming Googlebot actually crawled a URL, separate from indexing | Tells you about crawling, not indexing decisions |
None of these fully replaces the others. The CSE-based check is the fastest way to get a quick answer for a URL when you don't have (or don't want to use) Search Console access, but Search Console remains the authoritative source when you need to know why a page isn't indexed, not just whether it is.
Treat a single "not indexed" result as a lead, not a verdict. The most reliable workflow is to use this tool for fast, no-login spot checks and first-pass audits across a list of URLs, then confirm anything concerning through Google Search Console's URL Inspection tool, which pulls status directly from Google's index and explains the specific reason a page was excluded.
When checking a batch of URLs, always use the canonical, final version of each address — the exact form after any redirects, with the correct protocol and subdomain — since checking a redirected or malformed URL will produce a false "not indexed" reading even if the canonical version is indexed correctly.
Give freshly published pages a reasonable window before treating a negative result as a problem. Checking a page five minutes after publishing and finding it unindexed is expected behavior, not evidence of an issue.
For ongoing monitoring rather than one-off checks, prioritize your highest-value URLs — money pages, top landing pages, cornerstone content — rather than trying to check an entire large site through this tool one URL at a time.
The Google Custom Search JSON API that powers this kind of check operates on a query quota, and the free tier of that API has historically been capped at a modest number of queries per day (Google's documented free-tier limit for the Custom Search JSON API is 100 queries per day, with paid tiers available for higher volume). Tools built on top of this API inherit that constraint, which means very large-scale automated checking — thousands of URLs in a short window — isn't realistic through this method and isn't what it's designed for.
A CSE configured for full-web search draws on Google's index but isn't guaranteed to be byte-for-byte identical to what you'd see querying Google's primary search results directly; caching lag and result-set differences mean occasional mismatches are possible in either direction. This tool is best understood as a strong, convenient signal rather than an infallible source of truth — for anything business-critical, corroborate with Search Console.
The check also can't tell you why a page isn't indexed, only that it isn't (or that no match was found in this particular query). Diagnosing the cause — noindex tag, robots.txt block, canonical mismatch, quality assessment — requires looking at the page's source, headers, and, ideally, Search Console's coverage report.
Finally, this tool checks a single URL at a time based on what you submit. It doesn't crawl your site, doesn't discover URLs on its own, and doesn't replace an XML sitemap or a full technical SEO crawl for understanding site-wide indexation patterns.
No. The overwhelming majority of "not indexed" results are ordinary and unremarkable — a page that's simply new, hasn't been crawled yet, or has a technical issue like a stray noindex tag or a canonical pointing elsewhere. Manual actions and penalties are a small minority of the reasons a page fails to appear, and Search Console's Manual Actions report is the way to confirm or rule that out, not an index checker.
They're aiming at the same underlying question, but the manual site: search runs against Google's main results page directly, which Google has said is not a precise or complete indicator and which becomes unreliable to automate because of rate limiting. This tool instead queries the sanctioned Custom Search Engine API, which returns structured results and is meant for exactly this kind of programmatic lookup, at the cost of occasionally diverging slightly from what you'd see in the main search results.
Being indexed and ranking well for a specific query are separate things. A page can be fully indexed and still rank on page five for a competitive keyword because of thin content, weak backlink profile, poor relevance signals, or strong competition. Indexation is a prerequisite for ranking, not a guarantee of it.
Search Console is the authoritative source for your own verified property — trust it over any third-party check. A mismatch usually means the CSE result set surfaced a cached or slightly stale match, or the page was indexed briefly and then dropped. When the two disagree, treat Search Console's status as current truth and use the CSE check mainly for sites you can't verify in Search Console.
Yes — that's actually one of the main advantages of a CSE-based checker over Search Console, since Search Console only reports on properties you've verified ownership of. Checking a public URL through this tool doesn't require any access to that site.
No. The check queries Google's search index through an API; it doesn't crawl your site, doesn't send Googlebot to your page, and has no effect on how your site is crawled, indexed, or ranked. It's purely a read-only lookup against results Google has already computed.