link-check-lite 1.0.0__tar.gz

link_check_lite-1.0.0/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+What changed in link-check-lite, newest first.
+
+## 1.0.0 - 2026-11-04
+
+- First release.
+- Checks a text file of links and shows status codes, broken links and where redirects end up.
+- Exit code 1 when any link is broken, so it works in cron jobs and CI.
+- Free MCP server, `link-check-lite-mcp`, with one tool, `check_links`.
+- You can install it from PyPI with `pip install link-check-lite`.

link_check_lite-1.0.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 tidybyte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

link_check_lite-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include CHANGELOG.md
+include llms.txt
+include server.json

link_check_lite-1.0.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: link-check-lite
+Version: 1.0.0
+Summary: Check a file of links for status codes and redirects. Has a CLI and an MCP server.
+Author: Tidy Byte Tools
+License-Expression: MIT
+Project-URL: Homepage, https://tidybyte.gumroad.com
+Project-URL: Source, https://github.com/tidybytetools/link-check-lite
+Project-URL: Issues, https://github.com/tidybytetools/link-check-lite/issues
+Project-URL: Changelog, https://github.com/tidybytetools/link-check-lite/blob/main/CHANGELOG.md
+Keywords: links,link-checker,broken-links,redirects,http,status-code,cli,mcp,mcp-server
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Site Management :: Link Checking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.2
+Dynamic: license-file
+
+# link-check-lite
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/tidybytetools/link-check-lite/blob/main/LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![MCP server](https://img.shields.io/badge/MCP-stdio-purple.svg)](#use-it-from-claude-desktop-or-cursor-mcp)
+
+Free tool that checks a list of links. It tells you which ones work, which are broken, and where redirects end up.
+Need sitemaps, speed checks, sketchy-domain warnings or CSV reports? The paid version does that: **[link-check on Gumroad](https://tidybyte.gumroad.com)**
+
+MIT license. Python 3.10 or newer, on Windows, Mac and Linux. The checker itself uses only Python's built-in tools.
+
+<!-- mcp-name: io.github.tidybytetools/link-check-lite -->
+
+## Install
+
+```
+pip install link-check-lite
+```
+
+Or use pipx, which keeps it in its own space:
+
+```
+pipx install link-check-lite
+```
+
+Want the newest code from GitHub instead?
+
+```
+pip install git+https://github.com/tidybytetools/link-check-lite
+```
+
+## Use it
+
+Put your links in a text file, one per line. Lines that start with `#` are skipped.
+
+```
+link-check-lite links.txt
+link-check-lite links.txt -w 3 --timeout 20   # gentler and more patient
+```
+
+Example run:
+
+```
+OK   200 https://example.com/
+OK   200 https://httpbin.org/redirect/2  -> https://httpbin.org/get (2 redirects)
+FAIL 404 https://example.com/old-page
+FAIL --- https://no-such-site.example  ([Errno -2] Name or service not known)
+
+4 checked, 2 ok, 2 broken
+```
+
+Exit code is 0 when every link works and 1 when any link is broken, so it works in a cron job or CI.
+
+When you run it in a terminal it ends with one short line about the paid version. `--quiet` turns it off, and it never shows when output is piped.
+
+## Known limits
+
+- **Some sites block bots.** They may answer 403 or 429 even when the page opens fine in a browser.
+- **No JavaScript.** Redirects done with JavaScript are not followed.
+- **Text file only.** No CSV input, no sitemaps, and results print to the screen.
+- **No robots.txt and no per-site rate limit.** It checks 5 links at a time with a small pause. Don't point it at thousands of pages on one site.
+- **Not a safety check.** It does not tell you if a link is a scam.
+
+## Lite vs paid
+
+| | lite (free) | [link-check](https://tidybyte.gumroad.com) |
+|---|---|---|
+| Status codes and broken links | yes | yes |
+| Redirect chain and final URL | yes | yes |
+| Text file input | yes | yes |
+| CSV input and sitemap URLs (with sitemap index) | no | yes |
+| Response time and slow-link flag | no | yes |
+| http vs https checks | no | yes |
+| Look-alike and sketchy domain warnings (local rules) | no | yes |
+| robots.txt and one-hit-per-second per site | no | yes |
+| CSV, JSON and Markdown reports | no | yes |
+
+## How it compares to other free tools
+
+All of these are free. Pick what fits you.
+
+| | link-check-lite | [lychee](https://github.com/lycheeverse/lychee) | [linkchecker](https://github.com/linkchecker/linkchecker) | [muffet](https://github.com/raviqqe/muffet) |
+|---|---|---|---|---|
+| Checks a plain list of links | yes | yes | no, it crawls | no, it crawls |
+| Crawls a whole site | no | no | yes | yes |
+| Install | pip | binary / cargo | pip | binary / go |
+| Built-in MCP server for AI apps | yes | no | no | no |
+| Lots of options | no | yes | yes | yes |
+
+If you need to crawl a big site or check links inside Markdown files, lychee and linkchecker are great.
+
+## Use it from Claude Desktop or Cursor (MCP)
+
+There is a small free MCP server built in. It gives your AI app one tool, `check_links`. It needs [uv](https://docs.astral.sh/uv/).
+
+```
+uvx --from link-check-lite link-check-lite-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "link-check-lite": {
+      "command": "uvx",
+      "args": ["--from", "link-check-lite", "link-check-lite-mcp"]
+    }
+  }
+}
+```
+
+Tool: `check_links(urls, timeout=10.0)`. Send up to 200 links. It returns one result per link.
+
+## Use it from Python
+
+```python
+from link_check_lite import check_link
+print(check_link("https://example.com"))
+# {'url': 'https://example.com', 'status': 200, 'ok': True, 'final_url': 'https://example.com', 'redirects': [], 'error': None}
+```
+
+## For AI agents
+
+- **Use when:** you need to know if web links work and where their redirects end up.
+- **Don't use when:** you need to know if a link is safe, need a whole site crawled, or need speed or https checks. Use the paid version for those.
+- **Input:** a list of http(s) URLs (max 200 per MCP call), plus an optional `timeout` in seconds.
+- **Output:** a list of `{url, status, ok, final_url, redirects, error}`. `status` is null when the link could not connect. `ok` is true for 200-399. `redirects` lists each hop as `"CODE url"`.
+- CLI exit code is 0 when all links work and 1 when any link is broken or on error. See also [`llms.txt`](https://github.com/tidybytetools/link-check-lite/blob/main/llms.txt).
+
+## Tests
+
+```
+pip install "mcp>=1.2,<2"
+python3 -m unittest discover tests
+```
+
+The tests use a tiny local web server, so they don't need the internet.
+
+## License
+
+MIT. See `LICENSE`.

link_check_lite-1.0.0/README.md

@@ -0,0 +1,142 @@
+# link-check-lite
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/tidybytetools/link-check-lite/blob/main/LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![MCP server](https://img.shields.io/badge/MCP-stdio-purple.svg)](#use-it-from-claude-desktop-or-cursor-mcp)
+
+Free tool that checks a list of links. It tells you which ones work, which are broken, and where redirects end up.
+Need sitemaps, speed checks, sketchy-domain warnings or CSV reports? The paid version does that: **[link-check on Gumroad](https://tidybyte.gumroad.com)**
+
+MIT license. Python 3.10 or newer, on Windows, Mac and Linux. The checker itself uses only Python's built-in tools.
+
+<!-- mcp-name: io.github.tidybytetools/link-check-lite -->
+
+## Install
+
+```
+pip install link-check-lite
+```
+
+Or use pipx, which keeps it in its own space:
+
+```
+pipx install link-check-lite
+```
+
+Want the newest code from GitHub instead?
+
+```
+pip install git+https://github.com/tidybytetools/link-check-lite
+```
+
+## Use it
+
+Put your links in a text file, one per line. Lines that start with `#` are skipped.
+
+```
+link-check-lite links.txt
+link-check-lite links.txt -w 3 --timeout 20   # gentler and more patient
+```
+
+Example run:
+
+```
+OK   200 https://example.com/
+OK   200 https://httpbin.org/redirect/2  -> https://httpbin.org/get (2 redirects)
+FAIL 404 https://example.com/old-page
+FAIL --- https://no-such-site.example  ([Errno -2] Name or service not known)
+
+4 checked, 2 ok, 2 broken
+```
+
+Exit code is 0 when every link works and 1 when any link is broken, so it works in a cron job or CI.
+
+When you run it in a terminal it ends with one short line about the paid version. `--quiet` turns it off, and it never shows when output is piped.
+
+## Known limits
+
+- **Some sites block bots.** They may answer 403 or 429 even when the page opens fine in a browser.
+- **No JavaScript.** Redirects done with JavaScript are not followed.
+- **Text file only.** No CSV input, no sitemaps, and results print to the screen.
+- **No robots.txt and no per-site rate limit.** It checks 5 links at a time with a small pause. Don't point it at thousands of pages on one site.
+- **Not a safety check.** It does not tell you if a link is a scam.
+
+## Lite vs paid
+
+| | lite (free) | [link-check](https://tidybyte.gumroad.com) |
+|---|---|---|
+| Status codes and broken links | yes | yes |
+| Redirect chain and final URL | yes | yes |
+| Text file input | yes | yes |
+| CSV input and sitemap URLs (with sitemap index) | no | yes |
+| Response time and slow-link flag | no | yes |
+| http vs https checks | no | yes |
+| Look-alike and sketchy domain warnings (local rules) | no | yes |
+| robots.txt and one-hit-per-second per site | no | yes |
+| CSV, JSON and Markdown reports | no | yes |
+
+## How it compares to other free tools
+
+All of these are free. Pick what fits you.
+
+| | link-check-lite | [lychee](https://github.com/lycheeverse/lychee) | [linkchecker](https://github.com/linkchecker/linkchecker) | [muffet](https://github.com/raviqqe/muffet) |
+|---|---|---|---|---|
+| Checks a plain list of links | yes | yes | no, it crawls | no, it crawls |
+| Crawls a whole site | no | no | yes | yes |
+| Install | pip | binary / cargo | pip | binary / go |
+| Built-in MCP server for AI apps | yes | no | no | no |
+| Lots of options | no | yes | yes | yes |
+
+If you need to crawl a big site or check links inside Markdown files, lychee and linkchecker are great.
+
+## Use it from Claude Desktop or Cursor (MCP)
+
+There is a small free MCP server built in. It gives your AI app one tool, `check_links`. It needs [uv](https://docs.astral.sh/uv/).
+
+```
+uvx --from link-check-lite link-check-lite-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "link-check-lite": {
+      "command": "uvx",
+      "args": ["--from", "link-check-lite", "link-check-lite-mcp"]
+    }
+  }
+}
+```
+
+Tool: `check_links(urls, timeout=10.0)`. Send up to 200 links. It returns one result per link.
+
+## Use it from Python
+
+```python
+from link_check_lite import check_link
+print(check_link("https://example.com"))
+# {'url': 'https://example.com', 'status': 200, 'ok': True, 'final_url': 'https://example.com', 'redirects': [], 'error': None}
+```
+
+## For AI agents
+
+- **Use when:** you need to know if web links work and where their redirects end up.
+- **Don't use when:** you need to know if a link is safe, need a whole site crawled, or need speed or https checks. Use the paid version for those.
+- **Input:** a list of http(s) URLs (max 200 per MCP call), plus an optional `timeout` in seconds.
+- **Output:** a list of `{url, status, ok, final_url, redirects, error}`. `status` is null when the link could not connect. `ok` is true for 200-399. `redirects` lists each hop as `"CODE url"`.
+- CLI exit code is 0 when all links work and 1 when any link is broken or on error. See also [`llms.txt`](https://github.com/tidybytetools/link-check-lite/blob/main/llms.txt).
+
+## Tests
+
+```
+pip install "mcp>=1.2,<2"
+python3 -m unittest discover tests
+```
+
+The tests use a tiny local web server, so they don't need the internet.
+
+## License
+
+MIT. See `LICENSE`.

link_check_lite-1.0.0/link_check_lite.egg-info/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: link-check-lite
+Version: 1.0.0
+Summary: Check a file of links for status codes and redirects. Has a CLI and an MCP server.
+Author: Tidy Byte Tools
+License-Expression: MIT
+Project-URL: Homepage, https://tidybyte.gumroad.com
+Project-URL: Source, https://github.com/tidybytetools/link-check-lite
+Project-URL: Issues, https://github.com/tidybytetools/link-check-lite/issues
+Project-URL: Changelog, https://github.com/tidybytetools/link-check-lite/blob/main/CHANGELOG.md
+Keywords: links,link-checker,broken-links,redirects,http,status-code,cli,mcp,mcp-server
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Site Management :: Link Checking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.2
+Dynamic: license-file
+
+# link-check-lite
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/tidybytetools/link-check-lite/blob/main/LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![MCP server](https://img.shields.io/badge/MCP-stdio-purple.svg)](#use-it-from-claude-desktop-or-cursor-mcp)
+
+Free tool that checks a list of links. It tells you which ones work, which are broken, and where redirects end up.
+Need sitemaps, speed checks, sketchy-domain warnings or CSV reports? The paid version does that: **[link-check on Gumroad](https://tidybyte.gumroad.com)**
+
+MIT license. Python 3.10 or newer, on Windows, Mac and Linux. The checker itself uses only Python's built-in tools.
+
+<!-- mcp-name: io.github.tidybytetools/link-check-lite -->
+
+## Install
+
+```
+pip install link-check-lite
+```
+
+Or use pipx, which keeps it in its own space:
+
+```
+pipx install link-check-lite
+```
+
+Want the newest code from GitHub instead?
+
+```
+pip install git+https://github.com/tidybytetools/link-check-lite
+```
+
+## Use it
+
+Put your links in a text file, one per line. Lines that start with `#` are skipped.
+
+```
+link-check-lite links.txt
+link-check-lite links.txt -w 3 --timeout 20   # gentler and more patient
+```
+
+Example run:
+
+```
+OK   200 https://example.com/
+OK   200 https://httpbin.org/redirect/2  -> https://httpbin.org/get (2 redirects)
+FAIL 404 https://example.com/old-page
+FAIL --- https://no-such-site.example  ([Errno -2] Name or service not known)
+
+4 checked, 2 ok, 2 broken
+```
+
+Exit code is 0 when every link works and 1 when any link is broken, so it works in a cron job or CI.
+
+When you run it in a terminal it ends with one short line about the paid version. `--quiet` turns it off, and it never shows when output is piped.
+
+## Known limits
+
+- **Some sites block bots.** They may answer 403 or 429 even when the page opens fine in a browser.
+- **No JavaScript.** Redirects done with JavaScript are not followed.
+- **Text file only.** No CSV input, no sitemaps, and results print to the screen.
+- **No robots.txt and no per-site rate limit.** It checks 5 links at a time with a small pause. Don't point it at thousands of pages on one site.
+- **Not a safety check.** It does not tell you if a link is a scam.
+
+## Lite vs paid
+
+| | lite (free) | [link-check](https://tidybyte.gumroad.com) |
+|---|---|---|
+| Status codes and broken links | yes | yes |
+| Redirect chain and final URL | yes | yes |
+| Text file input | yes | yes |
+| CSV input and sitemap URLs (with sitemap index) | no | yes |
+| Response time and slow-link flag | no | yes |
+| http vs https checks | no | yes |
+| Look-alike and sketchy domain warnings (local rules) | no | yes |
+| robots.txt and one-hit-per-second per site | no | yes |
+| CSV, JSON and Markdown reports | no | yes |
+
+## How it compares to other free tools
+
+All of these are free. Pick what fits you.
+
+| | link-check-lite | [lychee](https://github.com/lycheeverse/lychee) | [linkchecker](https://github.com/linkchecker/linkchecker) | [muffet](https://github.com/raviqqe/muffet) |
+|---|---|---|---|---|
+| Checks a plain list of links | yes | yes | no, it crawls | no, it crawls |
+| Crawls a whole site | no | no | yes | yes |
+| Install | pip | binary / cargo | pip | binary / go |
+| Built-in MCP server for AI apps | yes | no | no | no |
+| Lots of options | no | yes | yes | yes |
+
+If you need to crawl a big site or check links inside Markdown files, lychee and linkchecker are great.
+
+## Use it from Claude Desktop or Cursor (MCP)
+
+There is a small free MCP server built in. It gives your AI app one tool, `check_links`. It needs [uv](https://docs.astral.sh/uv/).
+
+```
+uvx --from link-check-lite link-check-lite-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "link-check-lite": {
+      "command": "uvx",
+      "args": ["--from", "link-check-lite", "link-check-lite-mcp"]
+    }
+  }
+}
+```
+
+Tool: `check_links(urls, timeout=10.0)`. Send up to 200 links. It returns one result per link.
+
+## Use it from Python
+
+```python
+from link_check_lite import check_link
+print(check_link("https://example.com"))
+# {'url': 'https://example.com', 'status': 200, 'ok': True, 'final_url': 'https://example.com', 'redirects': [], 'error': None}
+```
+
+## For AI agents
+
+- **Use when:** you need to know if web links work and where their redirects end up.
+- **Don't use when:** you need to know if a link is safe, need a whole site crawled, or need speed or https checks. Use the paid version for those.
+- **Input:** a list of http(s) URLs (max 200 per MCP call), plus an optional `timeout` in seconds.
+- **Output:** a list of `{url, status, ok, final_url, redirects, error}`. `status` is null when the link could not connect. `ok` is true for 200-399. `redirects` lists each hop as `"CODE url"`.
+- CLI exit code is 0 when all links work and 1 when any link is broken or on error. See also [`llms.txt`](https://github.com/tidybytetools/link-check-lite/blob/main/llms.txt).
+
+## Tests
+
+```
+pip install "mcp>=1.2,<2"
+python3 -m unittest discover tests
+```
+
+The tests use a tiny local web server, so they don't need the internet.
+
+## License
+
+MIT. See `LICENSE`.

link_check_lite-1.0.0/link_check_lite.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+link_check_lite.py
+link_check_lite_mcp.py
+llms.txt
+pyproject.toml
+server.json
+link_check_lite.egg-info/PKG-INFO
+link_check_lite.egg-info/SOURCES.txt
+link_check_lite.egg-info/dependency_links.txt
+link_check_lite.egg-info/entry_points.txt
+link_check_lite.egg-info/requires.txt
+link_check_lite.egg-info/top_level.txt
+tests/test_lite.py
+tests/test_mcp.py

link_check_lite-1.0.0/link_check_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

link_check_lite-1.0.0/link_check_lite.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+link-check-lite = link_check_lite:main
+link-check-lite-mcp = link_check_lite_mcp:main

link_check_lite-1.0.0/link_check_lite.egg-info/requires.txt

@@ -0,0 +1 @@
+mcp<2,>=1.2

link_check_lite-1.0.0/link_check_lite.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+link_check_lite
+link_check_lite_mcp

link_check_lite-1.0.0/link_check_lite.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""link-check-lite: check a file of links for status codes and redirects.
+
+Free and MIT licensed. Paid version (sitemaps, CSV input, speed, https checks,
+odd-domain warnings, robots.txt, CSV/JSON/Markdown reports):
+https://tidybyte.gumroad.com
+"""
+import argparse, sys, time, urllib.error, urllib.parse, urllib.request
+from concurrent.futures import ThreadPoolExecutor
+
+__version__ = "1.0.0"
+PAID_URL = "https://tidybyte.gumroad.com"
+UA = "link-check-lite/1.0 (+https://github.com/tidybytetools/link-check-lite)"
+MAX_HOPS = 10
+
+
+class _Stop(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *a, **k):
+        return None
+
+
+_opener = urllib.request.build_opener(_Stop)
+
+
+def _hit(url, method, timeout):
+    req = urllib.request.Request(url, method=method, headers={"User-Agent": UA})
+    try:
+        with _opener.open(req, timeout=timeout) as r:
+            return r.status, r.headers.get("Location"), None
+    except urllib.error.HTTPError as e:
+        return e.code, e.headers.get("Location"), None
+    except urllib.error.URLError as e:
+        return None, None, str(e.reason)
+    except Exception as e:  # timeouts and odd errors
+        return None, None, str(e) or e.__class__.__name__
+
+
+def check_link(url, timeout=10.0):
+    """Check one link. Returns {url, status, ok, final_url, redirects, error}.
+
+    redirects is a list of "CODE url" hops. ok is True for a final status 200-399.
+    """
+    hops, cur, seen, err, code = [], url, set(), None, None
+    if urllib.parse.urlsplit(url).scheme not in ("http", "https"):
+        return {"url": url, "status": None, "ok": False, "final_url": url, "redirects": [], "error": "not an http(s) link"}
+    for _ in range(MAX_HOPS + 1):
+        code, loc, err = _hit(cur, "HEAD", timeout)
+        if code in (403, 405, 501):
+            code, loc, err = _hit(cur, "GET", timeout)  # some servers refuse HEAD
+        if err or code not in (301, 302, 303, 307, 308) or not loc:
+            break
+        hops.append(f"{code} {cur}")
+        seen.add(cur)
+        cur = urllib.parse.urljoin(cur, loc)
+        if cur in seen:
+            err = "redirect loop"
+            break
+    else:
+        err = f"more than {MAX_HOPS} redirects"
+    ok = err is None and code is not None and 200 <= code < 400
+    return {"url": url, "status": code, "ok": ok, "final_url": cur, "redirects": hops, "error": err}
+
+
+def read_links(path):
+    out = []
+    with open(path, encoding="utf-8-sig", errors="replace") as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith("#") and line not in out:
+                out.append(line if "://" in line else "https://" + line)
+    return out
+
+
+def check_links(urls, workers=5, timeout=10.0, delay=0.5):
+    """Check many links, a few at a time, with a short pause between starts."""
+    def job(i_url):
+        i, u = i_url
+        time.sleep(i * delay / max(workers, 1))
+        return check_link(u, timeout)
+    with ThreadPoolExecutor(max_workers=max(1, workers)) as ex:
+        return list(ex.map(job, enumerate(urls)))
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="link-check-lite", description="Check a file of links for status codes and redirects.")
+    ap.add_argument("file", help="text file, one link per line (# lines are skipped)")
+    ap.add_argument("-w", "--workers", type=int, default=5, help="links at the same time (default 5)")
+    ap.add_argument("--timeout", type=float, default=10, help="seconds per link (default 10)")
+    ap.add_argument("-q", "--quiet", action="store_true", help="hide the one-line note about the paid version")
+    ap.add_argument("--version", action="version", version=__version__)
+    a = ap.parse_args(argv)
+    try:
+        urls = read_links(a.file)
+    except OSError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    if not urls:
+        print("error: no links found", file=sys.stderr)
+        return 1
+    rows = check_links(urls, a.workers, a.timeout)
+    bad = 0
+    for r in rows:
+        mark = "OK  " if r["ok"] else "FAIL"
+        bad += not r["ok"]
+        line = f"{mark} {r['status'] or '---'} {r['url']}"
+        if r["redirects"]:
+            line += f"  -> {r['final_url']} ({len(r['redirects'])} redirect{'s' * (len(r['redirects']) > 1)})"
+        if r["error"]:
+            line += f"  ({r['error']})"
+        print(line)
+    print(f"\n{len(rows)} checked, {len(rows) - bad} ok, {bad} broken")
+    if not a.quiet and sys.stdout.isatty():
+        print(f"Need sitemaps, CSV/JSON reports, speed and sketchy-domain checks? {PAID_URL}")
+    return 1 if bad else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

link_check_lite-1.0.0/link_check_lite_mcp.py

@@ -0,0 +1,32 @@
+"""Free MCP server for link-check-lite (stdio).
+
+Run:  uvx --from git+https://github.com/tidybytetools/link-check-lite link-check-lite-mcp
+"""
+from mcp.server.fastmcp import FastMCP
+import link_check_lite as lite
+
+mcp = FastMCP("link-check-lite")
+
+
+@mcp.tool()
+def check_links(urls: list[str], timeout: float = 10.0) -> list[dict]:
+    """Check web links and follow their redirects.
+
+    urls: up to 200 http(s) links.
+    timeout: seconds to wait for each link.
+
+    Returns one result per link: {url, status, ok, final_url, redirects, error}.
+    status is the HTTP code of the last hop (null if it could not connect).
+    ok is true for 200-399. redirects lists each hop as "CODE url".
+    """
+    if len(urls) > 200:
+        raise ValueError("send 200 links or fewer per call")
+    return lite.check_links(list(urls), workers=5, timeout=timeout)
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

link_check_lite-1.0.0/llms.txt

@@ -0,0 +1,19 @@
+# link-check-lite
+
+> Free, MIT-licensed tool that checks web links for their HTTP status code and follows redirects to the final URL. Has a CLI, a Python API and a stdio MCP server.
+
+- Install: `pip install link-check-lite` (or from GitHub: `pip install git+https://github.com/tidybytetools/link-check-lite`)
+- CLI: `link-check-lite links.txt` prints one line per link (OK/FAIL, status, final URL). Exit 0 if all ok, 1 if any broken or on error.
+- Python: `from link_check_lite import check_link, check_links` returns dicts {url, status, ok, final_url, redirects, error}.
+- MCP: `uvx --from link-check-lite link-check-lite-mcp` exposes `check_links(urls: list[str], timeout=10.0) -> list[dict]` (max 200 links per call).
+
+## Use when
+- You need to know if links work and where redirects end up.
+
+## Don't use when
+- You need sitemaps, CSV input, response times, http vs https checks, look-alike domain warnings, robots.txt handling or CSV/JSON/Markdown reports. The paid version does those: https://tidybyte.gumroad.com
+- You need to know if a link is safe. This tool does not check for malware or phishing.
+
+## Links
+- [README](https://github.com/tidybytetools/link-check-lite/blob/main/README.md)
+- [Paid version](https://tidybyte.gumroad.com)

link_check_lite-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "link-check-lite"
+version = "1.0.0"
+description = "Check a file of links for status codes and redirects. Has a CLI and an MCP server."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Tidy Byte Tools"}]
+requires-python = ">=3.10"
+dependencies = [
+  "mcp>=1.2,<2",
+]
+keywords = ["links", "link-checker", "broken-links", "redirects", "http", "status-code", "cli", "mcp", "mcp-server"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Intended Audience :: End Users/Desktop",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Internet :: WWW/HTTP :: Site Management :: Link Checking",
+  "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://tidybyte.gumroad.com"
+Source = "https://github.com/tidybytetools/link-check-lite"
+Issues = "https://github.com/tidybytetools/link-check-lite/issues"
+Changelog = "https://github.com/tidybytetools/link-check-lite/blob/main/CHANGELOG.md"
+
+[project.scripts]
+link-check-lite = "link_check_lite:main"
+link-check-lite-mcp = "link_check_lite_mcp:main"
+
+[tool.setuptools]
+py-modules = ["link_check_lite", "link_check_lite_mcp"]

link_check_lite-1.0.0/server.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.tidybytetools/link-check-lite",
+  "title": "link-check-lite",
+  "description": "Check web links for status codes, broken links and redirect chains.",
+  "repository": {
+    "url": "https://github.com/tidybytetools/link-check-lite",
+    "source": "github"
+  },
+  "websiteUrl": "https://github.com/tidybytetools/link-check-lite",
+  "version": "1.0.0",
+  "packages": [
+    {
+      "registryType": "pypi",
+      "registryBaseUrl": "https://pypi.org",
+      "identifier": "link-check-lite",
+      "version": "1.0.0",
+      "runtimeHint": "uvx",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

link_check_lite-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

link_check_lite-1.0.0/tests/test_lite.py

@@ -0,0 +1,68 @@
+import io, os, sys, tempfile, threading, unittest
+from contextlib import redirect_stdout
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+import link_check_lite as lite
+
+
+class H(BaseHTTPRequestHandler):
+    def log_message(self, *a): pass
+    def _send(self, code, loc=None):
+        self.send_response(code)
+        if loc: self.send_header("Location", loc)
+        self.send_header("Content-Length", "2"); self.end_headers()
+        if self.command == "GET": self.wfile.write(b"hi")
+    def route(self):
+        p = self.path
+        if p == "/ok": return self._send(200)
+        if p == "/a": return self._send(301, "/b")
+        if p == "/b": return self._send(302, "/ok")
+        if p == "/loop": return self._send(302, "/loop")
+        if p == "/nohead": return self._send(405 if self.command == "HEAD" else 200)
+        return self._send(404)
+    do_GET = do_HEAD = route
+
+
+class T(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.srv = ThreadingHTTPServer(("127.0.0.1", 0), H)
+        threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
+        cls.b = f"http://127.0.0.1:{cls.srv.server_port}"
+    @classmethod
+    def tearDownClass(cls): cls.srv.shutdown(); cls.srv.server_close()
+
+    def test_ok(self):
+        r = lite.check_link(self.b + "/ok")
+        self.assertEqual((r["status"], r["ok"], r["redirects"]), (200, True, []))
+    def test_404(self):
+        r = lite.check_link(self.b + "/gone")
+        self.assertEqual((r["status"], r["ok"]), (404, False))
+    def test_redirects(self):
+        r = lite.check_link(self.b + "/a")
+        self.assertEqual(r["final_url"], self.b + "/ok"); self.assertEqual(len(r["redirects"]), 2)
+        self.assertTrue(r["redirects"][0].startswith("301 ")); self.assertTrue(r["ok"])
+    def test_loop(self):
+        r = lite.check_link(self.b + "/loop")
+        self.assertEqual(r["error"], "redirect loop"); self.assertFalse(r["ok"])
+    def test_head_refused(self):
+        self.assertEqual(lite.check_link(self.b + "/nohead")["status"], 200)
+    def test_cannot_connect(self):
+        r = lite.check_link("http://127.0.0.1:1/x", timeout=2)
+        self.assertIsNone(r["status"]); self.assertTrue(r["error"])
+    def test_not_http(self):
+        self.assertEqual(lite.check_link("mailto:a@b.c")["error"], "not an http(s) link")
+    def test_cli(self):
+        d = tempfile.mkdtemp(); p = os.path.join(d, "l.txt")
+        with open(p, "w") as f: f.write(f"# list\n{self.b}/ok\n{self.b}/a\n{self.b}/ok\n")
+        self.assertEqual(lite.read_links(p), [self.b + "/ok", self.b + "/a"])
+        buf = io.StringIO()
+        with redirect_stdout(buf): code = lite.main([p])
+        self.assertEqual(code, 0); self.assertIn("2 checked, 2 ok, 0 broken", buf.getvalue())
+        self.assertNotIn("gumroad", buf.getvalue())  # no upsell when not a terminal
+        with open(p, "a") as f: f.write(f"{self.b}/gone\n")
+        with redirect_stdout(io.StringIO()): self.assertEqual(lite.main([p]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

link_check_lite-1.0.0/tests/test_mcp.py

@@ -0,0 +1,45 @@
+import asyncio, os, sys, threading, unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from test_lite import H
+try:
+    import mcp  # noqa
+except ImportError:
+    mcp = None
+
+ROOT = os.path.join(os.path.dirname(__file__), "..")
+
+
+@unittest.skipIf(mcp is None, 'pip install "mcp>=1.2,<2" to run this test')
+class T(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.srv = ThreadingHTTPServer(("127.0.0.1", 0), H)
+        threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
+        cls.b = f"http://127.0.0.1:{cls.srv.server_port}"
+    @classmethod
+    def tearDownClass(cls): cls.srv.shutdown(); cls.srv.server_close()
+
+    def test_stdio_roundtrip(self):
+        from mcp import ClientSession, StdioServerParameters
+        from mcp.client.stdio import stdio_client
+        import json
+
+        async def go():
+            params = StdioServerParameters(command=sys.executable, args=[os.path.join(ROOT, "link_check_lite_mcp.py")], cwd=ROOT)
+            async with stdio_client(params) as (r, w):
+                async with ClientSession(r, w) as s:
+                    await s.initialize()
+                    tools = await s.list_tools()
+                    self.assertEqual([t.name for t in tools.tools], ["check_links"])
+                    res = await s.call_tool("check_links", {"urls": [self.b + "/a", self.b + "/gone"]})
+                    self.assertFalse(res.isError)
+                    data = res.structuredContent["result"] if res.structuredContent else [json.loads(c.text) for c in res.content]
+                    return data
+        data = asyncio.run(go())
+        self.assertEqual(data[0]["final_url"], self.b + "/ok")
+        self.assertEqual(data[1]["status"], 404)
+
+
+if __name__ == "__main__":
+    unittest.main()