Remove URL from Google: four situations, one tool each, and how long each one holds

Remove URL from Google is four different jobs. Your page, gone today: the Removals tool, within a day, for about six months. Your page, gone for good: 404 or 410, a password, or a noindex the crawler can read. Not your page: the Refresh Outdated Content form. A decision table, a thirty-line pre-removal check that applies Google's robots.txt precedence, and the six ways a removal quietly fails.

Crawling & IndexingSeptember 11, 202610 min read2345 views

Remove URL from Google: four situations, one tool each, and how long each one holds

People who type remove URL from Google into a search box are in one of four situations, and each has a different tool. A page you own that must vanish today: the Removals tool in Search Console, which hides it within a day and for about six months, then hands the job back to your server. A page you own that must stay gone: a 404 or 410, a password, or a noindex. A page you do not own: the Refresh Outdated Content form, which only works once the content is already gone. And a robots.txt rule, which is not on the list, because it hides the very signal Google needs to see.

Before you start

You need the URL to be inside a Search Console property you own; the Removals tool refuses anything else. You also need to be able to change what your server returns for that path, or at least its <head>. If the page lives on someone else's site, skip to the fourth row of the table below: the only lever you have is the form for outdated content, and it does not do what most people hope.

Why the Removals tool alone never finishes the job

Google keeps two things apart: what it shows and what it knows. The Removals tool changes the first. Google's own description is exact about the second: "Blocking a URL does not prevent Google from crawling your page, only from showing it in Search results" (Removals and SafeSearch reports tool, read 2026-09-12). The same page says "A successful request lasts only about six months", and lists the status you will see in the history table: "Temporarily removed: … You should make removal permanent or the page could appear again after about six months."

So the tool is a curtain, not a demolition. What Google knows only changes when the URL itself changes: it starts answering 404 or 410, it starts asking for a password, or it starts carrying a noindex that the crawler can read. That last clause is where most failed removals go wrong. The noindex documentation puts it in one sentence: "For the noindex rule to be effective, the page or resource must not be blocked by a robots.txt file … the crawler will never see the noindex rule, and the page can still appear in search results, for example if other pages link to it" (Block Search indexing with noindex, read 2026-09-12).

The Removals tool changes what Google shows. Only your server can change what Google knows.

Remove URL from Google: the four situations, and the tool for each

Pick your row first. The columns that matter are how fast the tool acts, how long its effect lasts, and where you look to confirm it worked.

Situation	Tool	Takes effect	Lasts	Confirm in
Your page, gone today	Removals tool → Temporarily remove URL	within a day	about 6 months	Removals history: Temporarily removed
Your page, gone for good	404 / 410, password, or noindex	next crawl	as long as the server keeps saying so	URL Inspection, then the page indexing report
Your page stays, the snippet must change	Removals tool → Clear snippet in search	within a day	until the next index	Removals history: Cleared
Not your page	Refresh Outdated Content form	after review	permanent if the content is really gone	Outdated content tab, if the site owner looks

The first two rows are meant to be used together. Google files the Removals tool under "Use this feature as the first step in permanently blocking a page from Google Search results", and the permanent step is one of three: "Remove or update the content on your site … and make sure that your web server returns either a 404 (Not Found) or 410 (Gone) HTTP status code", "Block access to the content, for example by requiring a password", or "Indicate that the page should not be indexed using the noindex meta tag. This is less secure than the other methods" (same help page). Which status code to return, and the two cases where neither fits, is its own chapter: 404 vs 410 for a removed page.

Do it in this order

The order matters because of the crawl clause above. If you hide the page first and change the server later, Google may recrawl the old page during the blackout and keep it. The help page has a fix for exactly that: "If you blocked the page before removing your content permanently (step 1), unblock and then reblock the page. This clears the page from the index, if it was recrawled after blocking."

Run the check below on the exact URL. Read the four lines it prints: status, X-Robots-Tag, meta robots, and whether robots.txt lets Googlebot in. If the last line says blocked, a noindex on that page is invisible; either remove the robots.txt rule or use a status code instead.
Ship the permanent change: the status code, the password, or the noindex. For a PDF or an image there is no <head>, so the header form is the only one: X-Robots-Tag: noindex.
Open Search Console → Removals → Temporary Removals → New Request → Temporarily remove URL. Choose "Remove this URL only" for one page, or "Remove all URLs with this prefix" for a folder. Both cover www and non-www, http and https; neither covers another subdomain.
Run URL Inspection with a live test. It shows the HTML Googlebot fetched, which is the only place a noindex can be confirmed from Google's side.
Come back in a week and open the page indexing report. The URL should have moved to "Excluded by noindex tag" or "Not found (404)". If it is still under an indexed reason, the crawler has not been back yet; the noindex documentation is blunt that "it may take months for Googlebot to revisit a page".

The deliverable: one check to run before you file anything

Thirty lines of Python, no dependencies. It fetches the page with a desktop browser user agent, prints the status and both forms of the robots rule, then reads the site's robots.txt and applies Google's precedence for that path: "crawlers use the most specific rule based on the length of the rule path. In case of conflicting rules, including those with wildcards, Google uses the least restrictive rule" (How Google interprets the robots.txt specification, read 2026-09-12). It ends with a soft 404 warning, because a 200 that says "not found" in its title is not a removal in Google's eyes.

#!/usr/bin/env python3
"""Before you file a removal: what does this URL tell a crawler right now?
Usage: python3 removal_check.py https://example.com/page"""
import re, sys, urllib.error, urllib.request
from urllib.parse import urlsplit
url = sys.argv[1]
UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/126.0 Safari/537.36"

def get(u):
    try:
        r = urllib.request.urlopen(urllib.request.Request(u, headers={"User-Agent": UA}), timeout=20)
        return r.status, r.url, r.headers, r.read(300000).decode("utf-8", "replace")
    except urllib.error.HTTPError as e:
        return e.code, u, e.headers, e.read(300000).decode("utf-8", "replace")

def robots_verdict(txt, path, agent="googlebot"):
    """Google-style: pick the most specific matching group, longest rule wins, allow wins a tie."""
    groups, cur = {}, []
    for line in txt.splitlines():
        line = line.split("#")[0].strip()
        if not line or ":" not in line: continue
        k, v = [x.strip() for x in line.split(":", 1)]
        if k.lower() == "user-agent":
            cur = [v.lower()]; groups.setdefault(v.lower(), [])
        elif k.lower() in ("allow", "disallow") and cur:
            for g in cur: groups[g].append((k.lower(), v))
    rules = next((groups[g] for g in groups if agent in g), groups.get("*", []))
    best = ("allow", "")
    for kind, pat in rules:
        if not pat: continue
        rx = "^" + re.escape(pat).replace(r"\*", ".*").replace(r"\$", "$")
        if re.match(rx, path) and (len(pat) > len(best[1]) or (len(pat) == len(best[1]) and kind == "allow")):
            best = (kind, pat)
    return best

status, final, hdrs, body = get(url)
xrt = hdrs.get("X-Robots-Tag") or "-"
meta = re.findall(r'(?is)<meta\s+name=["\'](?:robots|googlebot)["\']\s+content=["\']([^"\']+)', body)
parts = urlsplit(url)
rstatus, _, _, rtxt = get(f"{parts.scheme}://{parts.netloc}/robots.txt")
kind, pat = robots_verdict(rtxt if rstatus == 200 else "", parts.path + ("?" + parts.query if parts.query else ""))
title = re.search(r"(?is)<title[^>]*>(.*?)</title>", body)
print(f"status        {status}   (final url: {final})")
print(f"x-robots-tag  {xrt}")
print(f"meta robots   {', '.join(meta) or '-'}")
print(f"robots.txt    HTTP {rstatus}; " + (f"BLOCKS Googlebot by '{pat}' -> a noindex here is invisible to Google" if kind == "disallow" else "allows Googlebot"))
if status == 200 and title and re.search(r"(?i)not found|404|no longer", title.group(1)):
    print("warning       200 with a 'not found' title: that is a soft 404, not a removal")

We ran it on three real URLs on 2026-09-12. One page, one deleted path, one path that a robots.txt rule hides. These are three shapes, not a statistic.

$ python3 removal_check.py https://developers.google.com/search/docs/crawling-indexing/remove-information
status        200   (final url: https://developers.google.com/search/docs/crawling-indexing/remove-information)
x-robots-tag  -
meta robots   -
robots.txt    HTTP 200; allows Googlebot

$ python3 removal_check.py https://github.com/querywin-does-not-exist-20260912
status        404   (final url: https://github.com/querywin-does-not-exist-20260912)
x-robots-tag  -
meta robots   -
robots.txt    HTTP 200; allows Googlebot

$ python3 removal_check.py https://github.com/torvalds/linux/pulse
status        200   (final url: https://github.com/torvalds/linux/pulse)
x-robots-tag  -
meta robots   -
robots.txt    HTTP 200; BLOCKS Googlebot by '/*/*/pulse' -> a noindex here is invisible to Google

The third line is the one to learn from. GitHub's robots.txt disallows /*/*/pulse for every crawler, so if GitHub ever wanted that page out of Google, a noindex in its HTML would do nothing; the crawler is told not to look. Our first draft of this script used Python's built-in robotparser and reported that URL as allowed, because that module does not understand the * wildcard that Google's parser does. The verdict looked fine and was wrong. The matcher above is the replacement.

What goes wrong, and how you would notice

Six failures account for most "I removed it and it is still there" threads. Each has a visible symptom.

You did	What happens	Symptom
Removals tool only	Page returns after about six months	Status flips to "Removal expired"
noindex on a robots-blocked path	Googlebot never reads it	Page indexing report: "Indexed, though blocked by robots.txt"
Filed the block while the URL was already 404	Request expires early; a later page there is treated as new	The help page says so in plain words
Wrote noindex in robots.txt	Ignored: "not supported by Google"	URL stays indexed, robots.txt looks fine
"Remove this URL only" on a page with variants	Only the exact string is hidden; `.html`, parameters and case all differ	Sister URLs still rank
200 with a "not found" page body	Google classifies a soft 404 on its own schedule	Page indexing report: "Soft 404"

Two boundaries this chapter does not cross. It does not cover images, which have their own removal path in the same tool, and it does not cover legal or personal-information requests, which go through a form on a different Google property. It also cannot tell you how fast Googlebot will come back to read your noindex; that depends on the page, and Google's only public figure is the one above, "months".

One more thing the Removals tool does not touch: any crawler that is not Google. A URL hidden from Google Search is still fetched by every AI crawler that can reach it. If the goal is that a page stops being read at all, only the server-side methods work, and the AI crawler accessibility check will show you which crawlers can still reach the URL after you change it.

Common questions

How do I remove a URL from Google search permanently?

Make the server say so, then use the Removals tool to speed up the first part. Permanent means one of three things on your side: the URL answers 404 or 410, it requires a password, or it carries a noindex that Googlebot can crawl. The tool alone lasts about six months.

How long does it take to remove a URL from Google?

Through the Removals tool, "within a day", per Google's removals page (read 2026-09-12). Through a noindex or a 404 alone, on the next crawl, which Google's documentation describes as possibly "months" for a page of low importance. That is why the two are used together.

Can I remove a URL from Google Search Console if the site is not mine?

No. The Removals tool requires that "You must own the property in Search Console". For a page on someone else's site you have the Refresh Outdated Content form, which "You do not need to own the website to use", and which only succeeds when the page or the content is already gone; a request against a page that still shows the content comes back as "Denied: Content still on page".

Does robots.txt remove a page from Google?

No, and it can prevent removal. Google's removals page says "Don't use robots.txt as a way to block your page." A disallow rule stops the crawler from fetching the page, which means it cannot read a noindex there, and the URL can stay indexed from links alone. The chapter on when to noindex a page walks through that conflict.

What is the difference between "Temporarily remove URL" and "Clear snippet in search"?

The first hides the whole result for about six months. The second keeps the result and, in Google's words, "Wipes out the page description snippet in Search results until the page is indexed again", after which the snippet is rebuilt from whatever the page says then. Use the second when the page stays but a sentence on it had to go.

Part of the QueryWin handbook · Level 2