Url Analysis

Name: Url Analysis
Author: 89jobrien

89jobrien/steve

33 installs
4 repo stars
Updated April 11, 2026
89jobrien/steve

url-analysis is a Claude Code skill that validates URLs technically and contextually to ensure links are functional and appropriate.

About

url-analysis is a Claude Code skill that validates URLs both technically and contextually. It checks HTTP status, redirect chains, and SSL, then evaluates whether link text matches destination content and whether links are appropriate. Developers use it to audit links in documents or content for quality and relevance. It includes a validate-urls.py helper that outputs JSON results.

Validates URLs technically (HTTP status, redirects, SSL) and contextually
Extracts and categorizes links and checks relevance to their context
Bundles a validate-urls.py script that outputs JSON validation results

Url Analysis by the numbers

33 all-time installs (skills.sh)
Ranked #917 of 1,879 Documentation skills by installs in the Skillselion catalog
Data as of Jul 28, 2026 (Skillselion catalog sync)

At a glance

url-analysis capabilities & compatibility

Capabilities: url validation · link extraction · link audit
Use cases: seo · documentation

From the docs

What url-analysis says it does

This skill validates URLs both technically and contextually, ensuring links are functional and appropriate for their context.

SKILL.md

Technical Validation**: Checks HTTP status, redirects, SSL

SKILL.md

npx skills add https://github.com/89jobrien/steve --skill url-analysis

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/89jobrien/steve/url-analysis.svg)](https://skillselion.com/skills/89jobrien/steve/url-analysis)

Installs	33
repo stars	★ 4
Last updated	April 11, 2026
Repository	89jobrien/steve ↗

What it does

Validate and audit links in content for broken status, redirect chains, SSL, and contextual relevance.

Who is it for?

Developers and writers auditing links in documents or content for quality, relevance, and reachability.

When should I use this skill?

Validating links, analyzing URL context, extracting links from content, or auditing link quality.

What you get

A link audit flagging broken links, redirect chains, and context mismatches with fixes.

A URL validation report
Link relevance findings
JSON validation output

By the numbers

6 analysis capabilities from technical validation to quality assessment

Files

SKILL.mdMarkdownGitHub ↗

URL Analysis

This skill validates URLs both technically and contextually, ensuring links are functional and appropriate for their context.

When to Use This Skill

When validating URLs in content
When analyzing link context and appropriateness
When extracting links from documents
When checking link functionality
When ensuring link relevance
When auditing link quality

What This Skill Does

1. Technical Validation: Checks HTTP status, redirects, SSL 2. Contextual Analysis: Evaluates link appropriateness 3. Link Extraction: Extracts and categorizes links 4. Content Relevance: Checks if linked content matches context 5. Security Analysis: Identifies security concerns 6. Quality Assessment: Provides link quality scores

Helper Scripts

This skill includes Python helper scripts in scripts/:

`validate_urls.py`: Validates URLs from files or command line. Checks HTTP status codes, redirects, and accessibility. Outputs JSON with validation results.

  # Validate URLs from file
  python scripts/validate_urls.py document.md

  # Validate single URL
  python scripts/validate_urls.py --url https://example.com

How to Use

Validate URLs

Validate all URLs in this document

Check if these links are appropriate for their context

Specific Analysis

Extract and analyze all links in this content

Analysis Process

Technical Validation

Using Helper Script:

The skill includes a Python helper script for URL validation:

# Validate URLs from a file
python scripts/validate_urls.py document.md

# Validate a single URL
python scripts/validate_urls.py --url https://example.com

Checks:

HTTP status codes (200, 301, 404, etc.)
Redirect chains
Response times
SSL certificate validity
URL syntax validity

Contextual Analysis

Evaluates:

Link text vs. destination content
Semantic alignment
Publication date relevance
Authority of source
Value to reader

Link Extraction

Categorizes:

Internal vs. external links
Anchor links
File downloads
API endpoints

Examples

Example 1: URL Validation

Input: Validate URLs in blog post

Output:

## URL Analysis: Blog Post

### Technical Validation

**1. https://example.com/article**
- **Status**: 200 OK
- **Response Time**: 320ms
- **SSL**: Valid
- **Redirects**: None

**2. https://old-site.com/page**
- **Status**: 301 → https://new-site.com/page
- **Issue**: Redirect chain (should update link)
- **Fix**: Update to final destination

**3. https://broken-link.com**
- **Status**: 404 Not Found
- **Issue**: Broken link
- **Fix**: Remove or find alternative

### Contextual Analysis

**4. https://example.com/article**
- **Link Text**: "Learn more about React"
- **Destination**: React documentation
- **Relevance**: High ✓
- **Status**: Appropriate

**5. https://example.com/homepage**
- **Link Text**: "Advanced React patterns"
- **Destination**: Homepage (not specific article)
- **Relevance**: Low ✗
- **Issue**: Link text doesn't match destination
- **Fix**: Link to specific article or update link text

Best Practices

URL Validation

1. Check Status: Verify all links return 200 or appropriate redirect 2. Update Redirects: Use final destination, not redirect chains 3. Context Matters: Ensure links match their context 4. Security: Prefer HTTPS, check SSL validity 5. Relevance: Verify linked content matches expectations

Related Use Cases

Link validation
Content quality assurance
SEO link auditing
Documentation review
Link extraction and analysis

#!/usr/bin/env python3
"""URL validator for url-analysis skill.
Validates URLs and checks HTTP status codes.
"""

import json
import re
import sys
from pathlib import Path
from urllib.parse import urlparse

import requests  # type: ignore[import-untyped]
from requests.exceptions import (  # type: ignore[import-untyped]
    RequestException,
    Timeout,
)


def extract_urls(text: str) -> list[str]:
    """Extract URLs from text."""
    # URL pattern
    url_pattern = re.compile(
        r"https?://"  # http:// or https://
        r"(?:[-\w.])+"  # domain
        r"(?::[0-9]+)?"  # optional port
        r"(?:/(?:[\w/_.])*)?"  # path
        r"(?:\?(?:[\w&=%.])*)?"  # query string
        r"(?:#(?:[\w.])*)?",  # fragment
        re.IGNORECASE,
    )

    return url_pattern.findall(text)


def validate_url(url: str, timeout: int = 5) -> dict:
    """Validate a single URL."""
    result = {
        "url": url,
        "valid_syntax": False,
        "accessible": False,
        "status_code": None,
        "error": None,
        "redirects_to": None,
    }

    # Check URL syntax
    try:
        parsed = urlparse(url)
        if parsed.scheme and parsed.netloc:
            result["valid_syntax"] = True
        else:
            result["error"] = "Invalid URL syntax"
            return result
    except Exception as e:
        result["error"] = f"URL parsing error: {e}"
        return result

    # Check if URL is accessible
    try:
        response = requests.head(url, timeout=timeout, allow_redirects=True)
        result["accessible"] = True
        result["status_code"] = response.status_code

        # Check for redirects
        if response.history:
            result["redirects_to"] = response.url
            result["redirect_chain_length"] = len(response.history)

    except Timeout:
        result["error"] = "Request timeout"
    except RequestException as e:
        result["error"] = str(e)

    return result


def validate_urls_from_file(file_path: Path) -> dict:
    """Extract and validate URLs from a file."""
    content = file_path.read_text()
    urls = extract_urls(content)

    results = []
    for url in urls:
        validation = validate_url(url)
        results.append(validation)

    return {
        "file": str(file_path),
        "urls_found": len(urls),
        "validations": results,
    }


def main():
    """Main entry point."""
    if len(sys.argv) < 2:
        print("Usage: validate_urls.py <file> [--url <url>]")
        sys.exit(1)

    if "--url" in sys.argv:
        # Validate single URL
        url_index = sys.argv.index("--url")
        if url_index + 1 >= len(sys.argv):
            print("Error: --url requires a URL argument")
            sys.exit(1)
        url = sys.argv[url_index + 1]
        result = validate_url(url)
        print(json.dumps(result, indent=2))
    else:
        # Validate URLs from file
        file_path = Path(sys.argv[1])
        if not file_path.exists():
            print(f"Error: File not found: {file_path}")
            sys.exit(1)

        result = validate_urls_from_file(file_path)
        print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()