To pull every URL out of a Google Sheets column of hyperlinks, save the file as HTML, open that HTML in a text editor, and parse the anchor tags — Google Sheets writes each link as an element, so the destination address is right there in the markup. The Link Extractor does exactly that scan against pasted source: it walks the HTML, picks out the href value from every a, area, and link start tag, normalizes what it finds, removes duplicates, and gives you back one URL per line. You can copy that list into another column, a CSV file, or a second sheet for follow-up work. The parsing happens locally, the tool never requests the listed destinations, and the result is a snapshot you can rerun whenever the source changes. Because the scan follows a bounded set of documented rules, the output reflects only what the parser extracted from the source, which makes the workflow easy to reproduce across multiple sheets.
This approach is useful when the built-in =HYPERLINK() function does not return what you need, when the URLs live in cells that someone copy-pasted from another document, or when you need to audit a long list of outgoing links in one pass. The two common spreadsheet tricks — hovering and copying each link one at a time, or writing an Apps Script to read each cell — either do not scale or require permissions on the live sheet. Parsing the exported HTML works on any spreadsheet you can download and avoids touching the running file at all, which is helpful when the sheet is shared, read-only, or owned by another account.
Why the HTML Export Carries the Real Hrefs
When you choose File → Download → Web page (.html, zipped) in Google Sheets, the platform produces a zipped folder that contains a single HTML file representing the active sheet. Every hyperlink in that sheet, including those made with =HYPERLINK() and the ones that appear because Google auto-detected a pasted URL, becomes an tag with an href attribute. The exported file also carries stylesheet and icon references as elements, which the extractor picks up because it scans all three link-bearing start tags, not just anchors. Image-map elements are included for the same reason.
The result is a self-contained snapshot: the sheet's data, its links, and the resources the browser would have used to render the page, all in plain text. That makes the file easy to inspect, easy to version, and easy to feed into a parser. Because the parser reads source rather than rendering the file, you do not need a browser, a server, or an add-on — only a text editor to copy the markup out, and the Link Extractor to do the parsing.
How to Extract Links From Google Sheets Hyperlinks
- In Google Sheets, choose File → Download → Web page (.html, zipped). The file lands in your downloads folder as a zip archive named after the workbook.
- Unzip the archive. Inside you will find a single HTML file (typically named after the sheet) and a folder of supporting assets such as stylesheets and images. Open the HTML file in any plain-text editor.
- Select all the markup with Ctrl+A on Windows or Cmd+A on macOS and copy it. The full source is what the extractor needs.
- Open the Link Extractor and paste the copied HTML into the input field.
- If the sheet uses relative paths such as /pricing or ../guide and you want them resolved into absolute URLs, enter the page URL of the original published sheet in the optional base URL field. Without a base, relative values stay relative and no host is invented.
- Click Extract and read the three counts shown in the result panel: unique, duplicate, and skipped. The unique count is the size of your final list.
- Copy the one-per-line result and paste it into a new Google Sheets column, a CSV file, or any other destination for follow-up work.
What the Extractor Keeps and What It Skips
The parser applies a bounded set of rules so the output is predictable. The table below summarizes the main cases. Use it to anticipate what your unique count will look like before you paste the source.
| URL shape in the source | Action | Notes |
|---|---|---|
| Absolute https://... or http://... | Kept and normalized | One entry per distinct target. |
| mailto: or tel: | Kept | Legitimate destinations even though they are not web pages. |
| Root-relative or path-relative like /pricing or ../guide | Resolved when a valid HTTP(S) base URL is provided, otherwise kept as written | Without a base, no host is invented. |
| Scheme-relative like //cdn.example.com/x.css | Resolved when a valid HTTP(S) base URL is provided | Same rule as root-relative. |
| Same-page fragments like #section and empty values | Skipped | Not a navigable destination. |
| javascript:, data:, vbscript: | Skipped | Executable or embedded-data schemes are never returned. |
| Invalid absolute URLs | Skipped | Counted in the skipped total so the filter is visible. |
| Duplicates after normalization | Collapsed | First-seen order is retained in the result. |
The skipped count matters when the list looks shorter than you expected. A short result does not necessarily mean few links existed; it can mean several targets were filtered for safety, were empty, or were not valid URLs. Reading the three counts together — unique, duplicate, and skipped — is how you confirm the parser saw the full source and made the filtering decisions you expect.
Limits and Edge Cases to Check First
The extractor reads pasted source, so anything that only exists after the browser executes the page's scripts will not appear. A static Google Sheets HTML export does not normally inject hyperlinks through JavaScript, but if the sheet was published through an Apps Script web app, embedded in another page, or wrapped by a custom HTML template, dynamic links added at runtime can be missing. For a standard sheet download, the HTML file represents exactly what the sheet contained at the moment of export.
There is also a 200,000-character input ceiling. A single-sheet export with several hundred columns and many links can approach that limit, especially when the HTML carries inline styles and large embedded data URIs. When the input is close to the ceiling, split the source into two passes — one for the upper half of the file and one for the lower half — or trim non-essential markup such as inline CSS blocks before pasting. Very large documents should be handled with a controlled crawler rather than a single paste.
The base URL field requires an HTTP or HTTPS value and cannot contain credentials. This is intentional: a base with user:pass@host would leak user information into every resolved link, and a non-HTTP scheme would produce a misleading resolution context. If your sheet is published at a https://docs.google.com/spreadsheets/... URL, paste that full address as the base. The check is strict by design so the resolution context always reflects what the user typed.
The output is an inventory, not a health report. A listed URL may redirect, return an error, require authentication, be blocked by robots controls, or intentionally point off-site. The extractor does not label internal versus external links, does not test HTTP status, does not evaluate rel attributes, and does not assign SEO quality. Review and crawl the URLs with a separate authorized tool when those facts matter.
Verifying the Result Before You Trust the List
Once the one-per-line list is pasted into a fresh sheet, spot-check the first few entries by hand to confirm the export matches the source. Pay particular attention to cells where the visible label differs from the destination address — Google Sheets preserves both, and a manual count of distinct URLs is the easiest sanity check. If a column repeats the same URL many times in the original sheet, expect the duplicate count to be high.
For a deeper audit, compare the exported HTML against a browser DOM export of the same published sheet. Open the live sheet in a browser, view its source or save the rendered page, and diff the two files. Anything that appears only in the browser source and not in the downloaded HTML was likely inserted by a script or by the rendering engine, and it falls outside the scope of a source-based scan. Recognizing this gap is part of using a parser that does not execute JavaScript.
Finally, when the list needs a status, redirect, or rel review, feed the cleaned URLs to an authorized crawler or HTTP header tool. The Link Extractor ends at the inventory stage on purpose — combining extraction with network requests would couple two failure modes and make the result harder to reproduce. Treating it as a snapshot producer keeps the workflow clear and the output auditable.