Name: SEO Audit API: Check SEO Score & Improve Website Ranking
Brand: codezic
SKU: api-codezic-seo
Availability: InStock
Author: API Market

sujith raman

# 📊 SEO Audit API – Analyze Websites for SEO Optimization

## Overview

The SEO Audit API allows developers to programmatically analyze websites and retrieve comprehensive SEO reports using a REST API. It performs multiple SEO checks including title tag analysis, meta description validation, H1 heading verification, content length assessment, image alt attribute checking, and internal/external link analysis. This API is essential for improving website search engine rankings, identifying SEO issues, and optimizing web content for better visibility in search results.

## Features

*   **SEO Score Calculation:** Calculates an overall SEO score (0-100) based on multiple factors.
*   **Category-wise Scoring:** Provides scores for different SEO categories (Meta, Content, Structure, Images, Links).
*   **Issue Detection:** Identifies and lists critical SEO issues like missing title tags, meta descriptions, H1 tags, thin content, and missing image alt attributes.
*   **Smart Recommendations:** Offers priority-based recommendations with specific fixes and impact explanations.
*   **Content Analysis:** Analyzes content length, word count, and keyword density.
*   **Schema Detection:** Detects JSON-LD structured data schemas on the page.
*   **Link Analysis:** Counts internal and external links to assess site structure.
*   **Fast Response Time:** Provides rapid analysis ensuring minimal impact on application performance.
*   **JSON-Based Output:** Returns results in a structured JSON format for easy parsing and integration.
*   **Secure API Key Authentication:** Protects the API with secure API key-based authentication.
*   **Simple REST API:** Offers an intuitive REST interface for straightforward integration.

## Use Cases

*   **Website Audits:** Perform comprehensive SEO audits of multiple websites to identify optimization opportunities.
*   **SEO Monitoring:** Regularly monitor website SEO health and track improvements over time.
*   **Client Reporting:** Generate detailed SEO reports for clients in digital marketing agencies.
*   **Content Optimization:** Analyze content before publishing to ensure SEO best practices.
*   **Competitor Analysis:** Audit competitor websites to identify SEO strengths and weaknesses.
*   **CMS Integration:** Integrate SEO analysis into content management systems for real-time optimization suggestions.
*   **SEO Tools Development:** Build SEO tools and dashboards using the API as the backend analysis engine.

## API Documentation

### Base URL

All API requests should be made to: `https://prod.api.market/api/v1/magicapi/seoaudit`

### Authentication

Authentication is handled via API key. Include your API key in the `x-api-market-key` request header:

```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Endpoints

#### Analyze Website SEO

```http
GET /api/seo
```

This endpoint performs a comprehensive SEO analysis of the specified website URL.

##### Request

**Headers:**

```
x-api-market-key: YOUR_API_MARKET_KEY
```

**Query Parameters:**

| Parameter | Type   | Required | Description                    |
| --------- | ------ | -------- | ------------------------------ |
| url       | string | Yes      | The website URL to analyze     |

##### Example Request

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/seoaudit/api/seo?url=https://example.com" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

##### Response

**✅ Success Response (Status Code: 200 OK):**

```json
{
  "success": true,
  "url": "https://example.com",
  "score": 85,
  "grade": "Excellent",
  "categoryScores": {
    "meta": 90,
    "content": 80,
    "structure": 100,
    "images": 100,
    "links": 80
  },
  "summary": "Excellent! Your website has a strong SEO foundation with no critical issues.",
  "issues": [],
  "suggestions": [
    "Expand title to at least 30 characters"
  ],
  "recommendations": [
    {
      "priority": "medium",
      "fix": "Expand your title tag to at least 30 characters",
      "impact": "A longer, descriptive title helps search engines understand your content better and improves click-through rates.",
      "category": "meta"
    }
  ],
  "details": {
    "title": "Example Domain",
    "metaDescription": "This is an example description that demonstrates proper SEO meta tag usage.",
    "h1Count": 1,
    "contentLength": 1200,
    "wordCount": 180,
    "images": {
      "total": 2,
      "withAlt": 2
    },
    "links": {
      "internal": 3,
      "external": 1,
      "total": 4
    },
    "schema": [],
    "keywordDensity": {}
  }
}
```

**❌ Error Response (Status Code: 400 Bad Request):**

```json
{
  "error": "Invalid URL",
  "message": "Invalid URL provided. Please provide a valid URL starting with http:// or https://"
}
```

**❌ Error Response (Status Code: 401 Unauthorized):**

```json
{
  "error": "Unauthorized",
  "message": "API key is required. Include x-api-market-key header."
}
```

**❌ Error Response (Status Code: 403 Forbidden):**

```json
{
  "error": "Forbidden",
  "message": "Invalid API key."
}
```

**❌ Error Response (Status Code: 408 Request Timeout):**

```json
{
  "error": "Timeout",
  "message": "Request timed out. The website took too long to respond."
}
```

**❌ Error Response (Status Code: 502 Bad Gateway):**

```json
{
  "error": "Fetch Failed",
  "message": "Failed to fetch the website. Please check if the URL is accessible."
}
```

## Status Codes

*   **200 OK:** Request successful.
*   **400 Bad Request:** Invalid input parameters or malformed request.
    *   *Explanation:* This indicates that the provided URL is invalid, missing, or malformed.
    *   *How to handle:* Ensure the URL parameter is present and is a valid HTTP/HTTPS URL.
*   **401 Unauthorized:** Missing or invalid API key.
    *   *Explanation:* This means that the API key is either missing from the request headers or is invalid.
    *   *How to handle:* Verify that the `x-api-market-key` header is present and contains a valid API key.
*   **403 Forbidden:** Valid API key but insufficient permissions.
*   **408 Request Timeout:** The target website took too long to respond.
    *   *How to handle:* The website may be slow or unreachable. Try again with a different URL or implement retry logic.
*   **429 Too Many Requests:** Rate limit exceeded.
    *   *Explanation:* This occurs when the API usage exceeds the allowed rate limit.
    *   *How to handle:* Implement a retry mechanism with exponential backoff.
*   **500 Internal Server Error:** Server-side error.
    *   *Explanation:* This indicates an unexpected error on the server-side.
    *   *How to handle:* Retry the request after a short delay. If the error persists, contact support.
*   **502 Bad Gateway:** Failed to fetch the target website.
    *   *Explanation:* The target website may be down or blocking requests.
    *   *How to handle:* Verify the URL is accessible and try again.
*   **503 Service Unavailable:** Service temporarily unavailable.
    *   *Explanation:* The service is temporarily unavailable due to maintenance or high load.
    *   *How to handle:* Retry the request after a short delay.

## Rate Limits

Rate limit information can be found on your API.market dashboard. If you exceed the limit, implement a retry mechanism with exponential backoff.

## Error Handling

Proper error handling is crucial for building robust applications. The API returns detailed error responses in JSON format to help you diagnose and resolve issues.

Here are some error handling best practices:

*   **Interpret Error Responses:** Always parse the JSON response and check for "error" and "message" fields.
*   **Common Errors and Resolutions:**
    *   `Invalid URL` (Status 400): Ensure the URL parameter is present and is a valid HTTP/HTTPS URL (e.g., https://example.com).
    *   `URL parameter is required` (Status 400): Include the `url` query parameter in your request.
    *   `API key is required` (Status 401): Verify that the `x-api-market-key` header is included.
    *   `Invalid API key` (Status 403): Check that your API key is correct and active.
    *   `Request timed out` (Status 408): The target website is slow. Try again or use a different URL.
    *   `Failed to fetch the website` (Status 502): The target website may be down or blocking requests.
*   **Retry Strategies:** For transient errors like 408, 500, 502, or 503, implement a retry mechanism with exponential backoff. Start with a short delay (e.g., 1 second) and double the delay with each subsequent attempt, up to a maximum delay (e.g., 30 seconds).

Example Error Response:

```json
{
  "error": "Invalid URL",
  "message": "Invalid URL provided. Please provide a valid URL starting with http:// or https://"
}
```

## SEO Analysis Categories

The API analyzes websites across 5 main categories:

| Category | Weight | Checks Performed |
|----------|--------|------------------|
| Meta Tags | 30% | Title tag, Meta description |
| Content | 30% | Content length, H1 tags |
| Structure | 20% | Headings hierarchy, Links |
| Images | 10% | Alt attributes |
| Links | 10% | Internal/External links |

## SEO Scoring Rules

| Factor | Threshold | Deduction |
|--------|-----------|----------|
| Title | 30-60 characters | -10 |
| Meta Description | 120-160 characters | -10 |
| H1 | Exactly 1 required | -10 |
| Content Length | 800+ characters | -10 |
| Image Alt | 90%+ have alt text | -5 |
| Internal Links | 2+ required | -5 |

## Implementation Guide

This section provides detailed guidance on how to implement and use the SEO Audit API effectively.

### Example Code

```javascript
// JavaScript example
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/seoaudit";

async function analyzeSeo(url) {
  try {
    const response = await fetch(`${baseUrl}/api/seo?url=${encodeURIComponent(url)}`, {
      method: "GET",
      headers: {
        "x-api-market-key": apiKey
      },
    });

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

    const data = await response.json();
    return data;

  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

// Usage
analyzeSeo("https://example.com")
  .then(result => console.log("SEO Score:", result.score))
  .catch(error => console.error("Error:", error));
```

```python
# Python example
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/seoaudit"

def analyze_seo(url):
    headers = {
        "x-api-market-key": API_KEY
    }

    response = requests.get(
        f"{BASE_URL}/api/seo",
        params={"url": url},
        headers=headers
    )

    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return response.json()

# Usage
result = analyze_seo("https://example.com")
print(f"SEO Score: {result['score']}")
```

```bash
# cURL example
curl -X GET "https://prod.api.market/api/v1/magicapi/seoaudit/api/seo?url=https://example.com" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization

*   **Cache Frequent Analyses:** Cache analysis results for frequently audited websites to reduce API calls and improve performance.
*   **Handle Errors Properly:** Implement proper error handling to avoid unnecessary retries and ensure a smooth user experience.
*   **Avoid Exposing API Keys:** Never expose API keys in client-side code. Use a backend proxy to securely handle API requests.
*   **Monitor API Usage:** Monitor API usage and limits to prevent unexpected costs and ensure optimal performance.
*   **Batch Processing:** For multiple URLs, implement queue-based processing with appropriate delays between requests.

## Response Fields Reference

| Field | Type | Description |
|-------|------|-------------|
| success | boolean | Whether the request was successful |
| url | string | The analyzed website URL |
| score | integer | Overall SEO score (0-100) |
| grade | string | Score grade (Excellent/Good/Fair/Poor) |
| categoryScores | object | Scores for each SEO category |
| summary | string | Human-readable summary |
| issues | array | List of detected issues |
| suggestions | array | List of improvement suggestions |
| recommendations | array | Priority-based recommendations |
| details | object | Detailed analysis data |

## FAQ

**Q: What SEO factors does the API analyze?**

A: The API analyzes title tags, meta descriptions, H1 headings, content length, image alt attributes, internal/external links, keyword density, and schema markup.

**Q: How is the SEO score calculated?**

A: The score starts at 100 and deducts points for various issues: missing title (-10), missing meta description (-10), missing H1 (-10), thin content (-10), missing alt tags (-5), low internal links (-5).

**Q: How do I authenticate with the API?**

A: Use your API.market API key in the `x-api-market-key` header.

**Q: What happens if the target website is slow?**

A: If the website doesn't respond within 10 seconds, the API returns a 408 timeout error. Implement retry logic with exponential backoff.

**Q: Can I analyze any website?**

A: Yes, as long as the website is publicly accessible and returns valid HTML. Some websites may block automated requests.

**Q: What is the difference between issues, suggestions, and recommendations?**

A: Issues are critical problems that directly impact SEO. Suggestions are general improvements. Recommendations are prioritized actions with specific fixes and impact explanations.

**Q: How long does an analysis take?**

A: Most analyses complete within 2-5 seconds, depending on the target website's response time.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@api.market.

Analyze your website's SEO with our API. Get your SEO score, find issues, and get actionable recommendations to rank higher.

SEO Audit API: Check SEO Score & Improve Website Ranking

Free

Codezic

Analyze websites in real-time for comprehensive SEO insights, delivering a score, identifying issues, and suggesting fixes for enhanced search performance.