# Sitemap Freshness Auditor (`phoenix2810/sitemap-freshness-auditor`) Actor

Audit a public XML sitemap for lastmod coverage, stale URLs, child sitemap indexes, score, grade, and SEO maintenance recommendations.

- **URL**: https://apify.com/phoenix2810/sitemap-freshness-auditor.md
- **Developed by:** [Sanskar Jaiswal](https://apify.com/phoenix2810) (community)
- **Categories:** SEO tools, Developer tools, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.005 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Sitemap Freshness Auditor

Fetches and audits one public XML sitemap for freshness and maintenance signals. It reports URL count, sitemap index entries, lastmod coverage, stale URL count, score, grade, issues, and recommendations.

### Use cases

- Technical SEO checks before site launches and migrations.
- Scheduled monitoring for stale or incomplete XML sitemaps.
- Agency reporting for sitemap health across client sites.
- Data pipeline checks before submitting sitemap URLs to other SEO tools.
- Developer QA for CMS sitemap generation.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `startUrl` | string | Yes | Public sitemap XML URL or website URL. If a website URL is provided, the actor checks `/sitemap.xml`. HTTP and HTTPS only. |
| `staleAfterDays` | integer | No | A URL is stale when its `lastmod` date is older than this many days. Default: `365`. |
| `timeoutSeconds` | integer | No | Request timeout for the sitemap fetch. Default: `10`, range: `3` to `30`. |
| `maxBytes` | integer | No | Maximum response body size to read. Default: `2000000`, maximum: `5000000`. |

### Output

Each run pushes one dataset item.

| Field | Type | Description |
| --- | --- | --- |
| `inputUrl` | string | Original input URL. |
| `sitemapUrl` | string | Sitemap URL selected for audit. |
| `finalUrl` | string | Final fetched URL after redirects. |
| `ok` | boolean | True when the sitemap is reachable and scores at least 75. |
| `checkedAt` | string | ISO timestamp for the audit. |
| `status` | integer | HTTP status code from the sitemap fetch. |
| `contentType` | string | Response `Content-Type` header. |
| `bytes` | integer | Number of bytes read. |
| `staleAfterDays` | integer | Stale threshold used for the audit. |
| `score` | integer | Freshness score from 0 to 100. |
| `grade` | string | Letter grade from A to F. |
| `type` | string | Parsed sitemap type: `urlset` or `sitemapindex`. |
| `urlCount` | integer | Number of URL entries parsed. |
| `sitemapIndexCount` | integer | Number of child sitemap entries parsed. |
| `lastmodCount` | integer | Number of URL entries with `lastmod`. |
| `lastmodCoveragePercent` | integer | Percent of URL entries that include `lastmod`. |
| `staleUrlCount` | integer | Number of URLs older than `staleAfterDays`. |
| `sampleUrls` | array | Up to 20 parsed URL entries with `loc`, `lastmod`, `hasLastmod`, and `stale`. |
| `sitemapIndexes` | array | Up to 50 child sitemap entries from a sitemap index. |
| `issues` | array | Human-readable issues found during scoring. |
| `recommendations` | array | Recommended fixes. |
| `error` | string or null | Fetch or validation error, if any. |

### Example input

```json
{
  "startUrl": "https://example.com/sitemap.xml",
  "staleAfterDays": 365,
  "timeoutSeconds": 10,
  "maxBytes": 2000000
}
````

### Example output

```json
{
  "inputUrl": "https://example.com/sitemap.xml",
  "sitemapUrl": "https://example.com/sitemap.xml",
  "finalUrl": "https://example.com/sitemap.xml",
  "ok": true,
  "checkedAt": "2026-07-12T00:00:00.000Z",
  "status": 200,
  "contentType": "application/xml",
  "bytes": 12450,
  "staleAfterDays": 365,
  "score": 90,
  "grade": "A",
  "type": "urlset",
  "urlCount": 120,
  "sitemapIndexCount": 0,
  "lastmodCount": 120,
  "lastmodCoveragePercent": 100,
  "staleUrlCount": 2,
  "sampleUrls": [
    {
      "loc": "https://example.com/",
      "lastmod": "2026-07-01",
      "hasLastmod": true,
      "stale": false
    }
  ],
  "sitemapIndexes": [],
  "issues": ["2 URLs have stale lastmod dates"],
  "recommendations": ["Refresh stale content timestamps only when content materially changes."],
  "error": null
}
```

### Security

- Fetches only public HTTP and HTTPS URLs.
- Rejects URL credentials.
- Rejects localhost, private IPv4, private IPv6, link-local, and private DNS resolutions.
- Revalidates redirects before fetching the next URL.
- Reads a bounded response body to avoid oversized sitemap runs.
- Does not require login or collect credentials.

### Pricing

Suggested pay-per-event pricing:

| Event | Price |
| --- | ---: |
| Actor start | `$0.005` |
| Sitemap audited | `$0.01` |

Typical one-sitemap run cost: about `$0.015` before Apify platform charges. Apify keeps its standard commission and the actor owner receives the remainder.

### FAQ

#### Does this crawl every URL in the sitemap?

No. It parses the sitemap XML and audits metadata such as `lastmod`. It does not fetch every listed page.

#### Does it expand sitemap indexes?

No. It reports child sitemap entries from a sitemap index. Audit important child sitemap URLs directly when URL-level freshness details are needed.

#### Can I pass a website URL instead of a sitemap URL?

Yes. If the URL does not look like a sitemap path, the actor checks `/sitemap.xml` on the same origin.

#### Why does stale content not always mean a problem?

Some pages are intentionally evergreen. Use `staleAfterDays` to match your content maintenance policy.

#### Kill or keep metric

Keep this actor if it gets organic Store impressions, runs, revenue, or inbound SEO agency questions within 60 to 90 days. Improve the listing or pricing if impressions arrive without runs. Archive it if there is no discovery or usage.

# Actor input Schema

## `startUrl` (type: `string`):

Public sitemap XML URL or website URL. If a website URL is provided, the actor checks /sitemap.xml. HTTP and HTTPS only. Private IP ranges are blocked.

## `staleAfterDays` (type: `integer`):

A URL is marked stale when its lastmod date is older than this many days.

## `timeoutSeconds` (type: `integer`):

Timeout for fetching the sitemap.

## `maxBytes` (type: `integer`):

Maximum response body size to read. Larger sitemaps are stopped to keep runs bounded.

## Actor input object example

```json
{
  "startUrl": "https://example.com/sitemap.xml",
  "staleAfterDays": 365,
  "timeoutSeconds": 10,
  "maxBytes": 2000000
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrl": "https://example.com/sitemap.xml"
};

// Run the Actor and wait for it to finish
const run = await client.actor("phoenix2810/sitemap-freshness-auditor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrl": "https://example.com/sitemap.xml" }

# Run the Actor and wait for it to finish
run = client.actor("phoenix2810/sitemap-freshness-auditor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrl": "https://example.com/sitemap.xml"
}' |
apify call phoenix2810/sitemap-freshness-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=phoenix2810/sitemap-freshness-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sitemap Freshness Auditor",
        "description": "Audit a public XML sitemap for lastmod coverage, stale URLs, child sitemap indexes, score, grade, and SEO maintenance recommendations.",
        "version": "0.1",
        "x-build-id": "fPCDZQqumzpdZn0fq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/phoenix2810~sitemap-freshness-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-phoenix2810-sitemap-freshness-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/phoenix2810~sitemap-freshness-auditor/runs": {
            "post": {
                "operationId": "runs-sync-phoenix2810-sitemap-freshness-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/phoenix2810~sitemap-freshness-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-phoenix2810-sitemap-freshness-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Sitemap or website URL",
                        "pattern": "^https?://.+",
                        "type": "string",
                        "description": "Public sitemap XML URL or website URL. If a website URL is provided, the actor checks /sitemap.xml. HTTP and HTTPS only. Private IP ranges are blocked."
                    },
                    "staleAfterDays": {
                        "title": "Stale after days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "A URL is marked stale when its lastmod date is older than this many days.",
                        "default": 365
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout (seconds)",
                        "minimum": 3,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Timeout for fetching the sitemap.",
                        "default": 10
                    },
                    "maxBytes": {
                        "title": "Maximum sitemap bytes",
                        "minimum": 100000,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Maximum response body size to read. Larger sitemaps are stopped to keep runs bounded.",
                        "default": 2000000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
