Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11To extract a website’s favicon candidates, inspect the page’s HTML <link> elements for icon relations, preserve their metadata, and resolve each reference to an absolute URL. Also check for a linked web app manifest: it may declare more icons, whose relative paths must be resolved against the manifest URL. There is no single candidate every browser or platform will use.
What counts as a favicon candidate?
A favicon candidate is an image a page declares for an icon-related use. The main modern declaration is an HTML link such as <link rel="icon" href="/favicon-32.png">. Keep the declaration’s exact rel tokens and href, along with optional type, sizes, and media attributes.
Do not assume the icon lives at /favicon.ico. A page can use another path, an absolute URL, or an asset hosted on a CDN. Google Search Central documents icon and the historical shortcut icon relation, and also recognizes Apple touch icon relations for its documented extraction guidance. Keep those as distinct candidates instead of silently treating all icons as interchangeable. Google’s favicon guidance concerns Google Search, not a universal browser rule.
Extract icon links from the page HTML
Fetch the final page URL and parse its HTML with an HTML parser rather than searching the source with a regular expression. Parsers handle attribute order, quoting, entities, and malformed-but-recoverable markup more reliably. The following Python example uses requests and Beautiful Soup. Install dependencies with python -m pip install requests beautifulsoup4.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →#1 Best Overall
from urllib.parse import urljoin
import requests
from bs4 import BeautifulSoup
page_url = "https://example.com/"
response = requests.get(page_url, timeout=20)
response.raise_for_status()
# Use the final URL after redirects as the base for document-relative links.
final_url = response.url
soup = BeautifulSoup(response.text, "html.parser")
candidates = []
for link in soup.find_all("link", href=True):
rel_value = link.get("rel", [])
rel_tokens = [str(token).lower() for token in rel_value]
if not any(token in {"icon", "shortcut", "apple-touch-icon",
"apple-touch-icon-precomposed"}
for token in rel_tokens):
continue
reference = link["href"]
candidates.append({
"source": "html",
"rel": rel_tokens,
"reference": reference,
"url": urljoin(final_url, reference),
"type": link.get("type"),
"sizes": link.get("sizes"),
"media": link.get("media"),
})
for candidate in candidates:
print(candidate)The parser returns declarations, not proof that an image exists or can be downloaded. A relative URL is resolved against the final document URL, which matters when the original address redirects. Preserve the original reference as well as the resolved URL: it helps explain where a candidate came from and makes later debugging possible.
Preserve selection hints without over-interpreting them
sizes can advertise dimensions, type can identify a media format, and media can condition a link on a media query. MDN explains that browsers can use these hints when choosing among multiple rel="icon" links. They are useful metadata, not a promise that your extraction code can reproduce every browser’s choice. MDN’s rel reference also describes platform variation; for certain web clip or startup-placeholder uses, Apple platforms use apple-touch-icon rather than the ordinary rel="icon" pathway.
Check the web app manifest too
A page may link a JSON-based web app manifest with <link rel="manifest" href="/site.webmanifest">. If present, fetch it and inspect its icons array. Each icon entry requires src; sizes, type, and purpose are optional. Crucially, resolve the manifest URL against the page first, then resolve each icon’s src against the manifest file URL—not against the HTML page.
import json
from urllib.parse import urljoin
manifest_link = soup.find("link", rel=lambda value: value and
"manifest" in [str(x).lower() for x in
(value if isinstance(value, list) else [value])],
href=True)
if manifest_link:
manifest_reference = manifest_link["href"]
manifest_url = urljoin(final_url, manifest_reference)
manifest_response = requests.get(manifest_url, timeout=20)
manifest_response.raise_for_status()
manifest = manifest_response.json()
for icon in manifest.get("icons", []):
if not isinstance(icon, dict) or not icon.get("src"):
continue
candidates.append({
"source": "manifest",
"manifest_url": manifest_url,
"reference": icon["src"],
"url": urljoin(manifest_url, icon["src"]),
"type": icon.get("type"),
"sizes": icon.get("sizes"),
"purpose": icon.get("purpose"),
})The manifest model and icon properties are described by the MDN manifest icon reference and the W3C Web Application Manifest specification. Keep HTML and manifest candidates distinguishable in the result: their metadata and URL bases differ.
Rank #2
- HTML CSS Design and Build Web Sites
- Comes with secure packaging
- It can be a gift option
Record what you found and what you could fetch
A useful metadata extractor reports discovery separately from retrieval. For each candidate, retain:
- The source page’s final URL and whether the declaration came from HTML or a manifest.
- The original
hreforsrcstring and the resolved absolute URL. - All declared fields: relation tokens, type, sizes, media, and—when from a manifest—purpose.
- The fetch outcome, such as HTTP status, redirect destination, and whether the response could be validated as an image.
Fetching candidates is an additional operation; a declaration alone does not prove the URL is reachable by your client or returns a valid image. The manifest specification describes cross-origin processing requirements in relevant cases, and icon image fetching is governed by the manifest owner’s img-src Content Security Policy. An external extractor may therefore discover a URL that it cannot retrieve. Treat a failed fetch as a fetch failure, not evidence that the page never declared the candidate.
Choose candidates for your use case
There is no established cross-browser precedence algorithm that an independent scraper can faithfully reproduce. Keep the full candidate set and let the consuming application apply its own needs. A search result, browser tab, installed web app, and iOS web clip can rely on different declarations or platform behavior.
| Metadata source | What it can provide | URL resolution and caveat |
|---|---|---|
| HTML link elements | rel, href, optional type, sizes, and media; Google’s guidance also recognizes Apple touch icon relations. |
Resolve relative href against the final page URL. Multiple links can coexist and browser selection varies. |
| Web app manifest | An icons array with required src and optional sizes, type, and purpose. |
Resolve each relative src against the manifest URL. Cross-origin rules and CSP can affect fetching. |
For a particular consumer, compare the use context, dimensions, format, media condition, manifest purpose, successful image validation, and platform behavior. Do not substitute a brand logo or Open Graph preview image just because it looks like the site’s icon: those are separate metadata declarations, not evidence of a favicon.
Rank #3
Google Search display is a separate outcome
Extracting a declaration does not guarantee that Google will show it in search results. Google’s documentation sets eligibility guidance and says display is not guaranteed; recrawling and processing may take several days to several weeks depending on how its systems determine refresh needs. That timing is Google Search Central’s qualitative guidance, not a fixed service-level target or a promise for every page.
Browser-based alternative: ScreenshotNeo
If the next step is to inspect how the page actually renders rather than only parse its metadata, ScreenshotNeo is a screenshot API and MCP server for developers. A screenshot can help you visually check a page, but it does not replace parsing the HTML or manifest for favicon URLs.
Or skip the browser setup
Make one GET request for a screenshot; see the ScreenshotNeo API documentation for the available parameters.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpScreenshotNeo accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. The Free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000 shots. Sign up for 1,000 free screenshots a month, with no card required.
Troubleshooting favicon extraction
No icon link appears in the HTML
Check the manifest link and its icon array. Do not assume the conventional /favicon.ico exists; if you choose to probe that conventional path as a fallback, label it as a guess rather than a declared candidate.
Rank #4
- Brand: Wiley
- Set of 2 Volumes
- A handy two-book set that uniquely combines related technologies Highly visual format and accessible language makes these books highly effective learning tools Perfect for beginning web designers and front-end developers
The resolved URL points to the wrong location
Confirm you used the response’s final URL after redirects for HTML-relative references. For manifest icons, use the resolved manifest URL as the base. Preserve the input reference to make this distinction auditable.
The URL is discovered, but fetching fails
Record the HTTP result separately from discovery. Check redirects, response status, cross-origin manifest processing, and the manifest owner’s img-src policy. Do not report an unreachable candidate as if no metadata declared it.
Several candidates disagree
Return them all with their attributes and source. The available documentation does not establish one universal precedence rule for an independent extractor; selection depends on consumer and platform.
A screenshot does not reveal the favicon URL
A screenshot shows rendered pixels, not the structured link declarations. Use HTML and manifest parsing for URL extraction; use a screenshot only when visual verification is useful.
Chrome extension retrieval is not a generic extraction API
Chrome documents a special favicon retrieval facility for Manifest V3 extensions, with an additional web-accessible-resource declaration requirement when it is used from content scripts. That is a Chrome-extension-specific path, not a generic endpoint for website metadata extraction. Because the cited Chrome documentation is older than the other technical references, verify the current API details before building on it. Chrome’s favicon retrieval documentation describes that extension use case.
Frequently Asked Questions
Should my extractor return one favicon or every candidate?
Return every declared candidate with its source and metadata unless your application has a clearly defined consumer-specific selection rule.
Does Google Search show every favicon a site declares?
No. Google’s eligibility guidance does not guarantee display, and its recrawl timing is qualitative rather than a fixed deadline.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
