Back to SEO Checker

SEO & Accessibility Checker

API Documentation & Usage Guide

Overview

The SEO Checker reads public HTML and reports measurable on-page SEO, accessibility basics, and response-performance findings. It can scan one page or up to 50 URLs found in a sitemap. The response also includes an AI-assisted priority overview grounded in the scanner findings.

Features

  • Scan scope: Checks one page or up to 50 URLs from a sitemap
  • SEO Scoring: Provides SEO score (0-100) with detailed breakdown
  • Accessibility basics: Checks language, viewport configuration, and image alternative text in returned HTML
  • Response health: Reports HTML size, time to first byte, compression, and caching signals
  • Issue Detection: Identifies critical issues and warnings
  • Technical SEO: Checks sitemap.xml and robots.txt
  • Search Preview: Shows how your site appears in Google search results
  • AI issue overview: Organizes verified findings into a concise repair order

Using the Web Interface

Step 1: Access the Tool

Navigate to https://330hosting.com/seo-checker/

Step 2: Enter Website URL

In the "Website page to scan" field, enter your website URL. You can enter:

  • Full URL: https://example.com
  • Domain only: example.com (https:// will be added automatically)
  • With path: https://example.com/about

Step 3: Analyze

  1. Click the "Analyze website" button
  2. Wait for the analysis to complete (may take 1-5 minutes depending on site size)
  3. Review the results in the following sections:
    • Score Summary: Overall, on-page SEO, access basics, and response health
    • Score Breakdown: Individual scores for SEO, Accessibility, and Performance
    • Issues Summary: Count of critical issues and warnings
    • Technical SEO Status: Sitemap and robots.txt information
    • Search Results Preview: How your site appears in Google
    • Evidence Views: Critical findings, warnings, passed checks, and pages
    • AI Overview: A short priority list based only on returned scanner data

Step 4: Review Results

  • Critical: Page-level findings the scanner marks for immediate attention
  • Warnings: Improvements that should be reviewed in page context
  • Passed: Checks that returned the expected signal
  • Pages: URL-level results for sitemap scans

API Documentation

API Endpoint

Endpoint: https://330hosting.com/api/seo-check

Method: GET

Parameters:

  • url (required): The website URL to analyze
  • format (optional): Response format - json (recommended)
  • scanSitemap (optional): Set to true to scan all pages from sitemap.xml
  • scanNestedSitemaps (optional): Set to true to also scan nested sitemap index files
  • maxPages (optional): Maximum number of pages to scan when using a sitemap (maximum: 50)
GET https://330hosting.com/api/seo-check?url=https://example.com&format=json&scanSitemap=true

The numeric scores and findings are calculated by the 330 Hosting Worker. The optional overview is generated from those findings using OpenAI, Workers AI, or a deterministic fallback. It does not send the scanned page HTML to the language model.

Request Examples

cURL

# Single page scan
curl "https://330hosting.com/api/seo-check?url=https://example.com&format=json"

# Scan all pages from sitemap
curl "https://330hosting.com/api/seo-check?url=https://example.com&format=json&scanSitemap=true&maxPages=50"

JavaScript (Fetch API)

async function checkSEO(url, scanSitemap = false) {
  try {
    const params = new URLSearchParams({
      url: url,
      format: 'json'
    });

    if (scanSitemap) {
      params.append('scanSitemap', 'true');
    }

    const response = await fetch(
      `https://330hosting.com/api/seo-check?${params.toString()}`
    );

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error checking SEO:', error);
    return null;
  }
}

// Usage - single page
const results = await checkSEO('https://example.com');
console.log('SEO Score:', results.summary?.seoScore);

// Usage - full site scan
const siteResults = await checkSEO('https://example.com', true);
console.log('Pages scanned:', siteResults.pagesScanned);

Python

import requests

def check_seo(url, scan_sitemap=False, max_pages=50):
    api_url = "https://330hosting.com/api/seo-check"
    params = {
        "url": url,
        "format": "json"
    }

    if scan_sitemap:
        params["scanSitemap"] = "true"
        params["maxPages"] = max_pages

    try:
        response = requests.get(api_url, params=params, timeout=300)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error checking SEO: {e}")
        return None

# Usage - single page
results = check_seo("https://example.com")
if results and results.get("success"):
    print(f"SEO Score: {results['summary']['seoScore']}")
    print(f"Accessibility Score: {results['summary']['accessibilityScore']}")
    print(f"Performance Score: {results['summary']['performanceScore']}")

# Usage - full site scan
site_results = check_seo("https://example.com", scan_sitemap=True)
if site_results:
    print(f"Pages scanned: {site_results.get('pagesScanned', 0)}")

Response Format

Success Response

{
  "success": true,
  "summary": {
    "seoScore": 89,
    "accessibilityScore": 92,
    "performanceScore": 85,
    "criticalIssues": 3,
    "warnings": 12
  },
  "aiOverview": {
    "headline": "Fix the missing description first.",
    "summary": "The checked pages have a usable base with several page-level improvements.",
    "priorities": [
      {
        "title": "Add the missing page description",
        "why": "The scanner did not find a meta description.",
        "action": "Write a page-specific description that matches the search intent.",
        "impact": "high"
      }
    ],
    "quickWin": "Add the missing description before lower-priority changes.",
    "generatedBy": "openai"
  },
  "pagesScanned": 15,
  "sitemapInfo": {
    "found": true,
    "url": "https://example.com/sitemap.xml",
    "pageCount": 15,
    "valid": true
  },
  "robotsInfo": {
    "found": true,
    "url": "https://example.com/robots.txt",
    "valid": true,
    "hasSitemap": true,
    "allowsAll": true
  },
  "pages": [...],
  "seo": {...},
  "accessibility": {...}
}

Error Response

{
  "success": false,
  "error": "Unable to fetch the website. Please check that the URL is correct and accessible."
}

Response Fields

Summary Object

  • seoScore (number): SEO score from 0-100
  • accessibilityScore (number): Accessibility score from 0-100
  • performanceScore (number): Performance score from 0-100
  • criticalIssues (number): Count of critical issues found
  • warnings (number): Count of warnings found

AIOverview Object

  • headline (string): Plain-language result summary
  • summary (string): Context based on verified scores and findings
  • priorities (array): Up to three ordered repair recommendations
  • quickWin (string): First practical action
  • generatedBy (string): openai, workers-ai, or rules

SitemapInfo Object

  • found (boolean): Whether sitemap.xml was found
  • url (string): URL of the sitemap
  • totalUrls (number): Number of URLs found in the sitemap
  • scannedUrls (number): Number of listed URLs included in this scan

RobotsInfo Object

  • found (boolean): Whether robots.txt was found
  • url (string): URL of robots.txt
  • hasSitemap (boolean): Whether robots.txt references a sitemap
  • allowsAll (boolean): Whether robots.txt allows all crawlers

Issue Object

  • type (string): Issue type identifier
  • severity (string): "critical" or "warning"
  • description (string): Description of the issue
  • fix (string, optional): Recommended fix

Error Handling

400 Bad Request

  • Missing url parameter
  • Invalid URL format

502 Fetch Error

  • Website could not be accessed
  • Network errors
  • The URL returned non-HTML or minimal content

429 Too Many Requests

  • The endpoint currently allows eight requests per minute per client
  • Wait for the Retry-After period before sending another request

Best Practices

  • URL Format: Always use full URLs with protocol (https://example.com)
  • Timeout Handling: Allow enough time for the requested scan scope and handle network failure
  • Error Handling: Always check success field before accessing results
  • Pagination: For large sites, consider using maxPages to limit analysis
  • Privacy: Do not submit URLs containing private preview tokens or password-reset values
  • Respectful Usage: Don't spam the API with rapid requests

Use Cases

  • Website Triage: Find page-level SEO and accessibility basics that need review
  • CI/CD Integration: Automated checks in deployment pipelines
  • Monitoring: Scheduled checks to track this scanner's page-level signals over time
  • Client Review: Prepare a first-pass list for a manual SEO audit
  • Competitor Analysis: Analyze competitor websites
  • Pre-Launch Checks: Verify SEO before launching new sites

Support

For questions, issues, or feature requests: