# Web App Manifest Auditor (`phoenix2810/web-app-manifest-auditor`) Actor

"Enrich public GitHub repository URLs with stars, forks, topics, license, activity, owner metadata, release data, and lead-scoring signals. Built for B2B lead generation, devtools research, and competitive intelligence."

- **URL**: https://apify.com/phoenix2810/web-app-manifest-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

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Web App Manifest Auditor

Audit one public web page for web app manifest and favicon readiness. The actor fetches the page, finds manifest and icon links, validates the manifest JSON, and returns a structured score with issues and recommendations.

### Use cases

- Check launch pages for missing favicons or web app manifests.
- Monitor PWA installability basics across marketing sites and docs portals.
- Validate CMS templates after redesigns or migrations.
- Feed structured manifest and icon diagnostics into QA dashboards.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `startUrl` | string | Yes | Public HTTP or HTTPS page URL to audit. Credentials and private network targets are rejected. |
| `timeoutSeconds` | integer | No | Request timeout for page and manifest fetches. Default is 10 seconds. |

### Output

Each run pushes one dataset item.

| Field | Type | Description |
| --- | --- | --- |
| `inputUrl` | string | Original URL submitted in the input. |
| `normalizedInputUrl` | string | URL after adding a default HTTPS scheme when omitted. |
| `finalUrl` | string | Final page URL after safe redirects. |
| `status` | integer or null | HTTP status returned by the page fetch. |
| `ok` | boolean | True when the page fetch completed with a 2xx or 3xx status and no fetch error. |
| `checkedAt` | string | ISO timestamp for the audit. |
| `manifestUrl` | string or null | First resolved `rel="manifest"` URL found on the page. |
| `manifestStatus` | integer or null | HTTP status returned by the manifest fetch. |
| `manifestValid` | boolean | True when the manifest was reachable and parsed as JSON. |
| `manifestName` | string or null | Manifest `name`, when present. |
| `manifestShortName` | string or null | Manifest `short_name`, when present. |
| `faviconCount` | integer | Number of favicon, shortcut icon, mask icon, and Apple touch icon links found. |
| `favicons` | array | Icon link records with `rel`, `href`, `resolvedHref`, `sizes`, and `type`. |
| `manifestIconCount` | integer | Number of icons declared in the manifest. |
| `manifestIcons` | array | Raw manifest icon records. |
| `hasName` | boolean | True when the manifest has `name` or `short_name`. |
| `hasStartUrl` | boolean | True when the manifest has `start_url`. |
| `hasDisplay` | boolean | True when the manifest has `display`. |
| `hasThemeColor` | boolean | True when the manifest has `theme_color`. |
| `score` | integer | Readiness score from 0 to 100. |
| `grade` | string | Letter grade from A to F. |
| `issues` | array | Problems found during the audit. |
| `recommendations` | array | Suggested fixes. |
| `error` | string or null | Fetch or validation error, when one occurred. |

### Example input

```json
{
  "startUrl": "https://example.com",
  "timeoutSeconds": 10
}
```

### Example output

```json
{
  "inputUrl": "https://example.com",
  "normalizedInputUrl": "https://example.com/",
  "finalUrl": "https://example.com/",
  "status": 200,
  "ok": true,
  "checkedAt": "2026-07-15T00:00:00.000Z",
  "manifestUrl": "https://example.com/site.webmanifest",
  "manifestStatus": 200,
  "manifestValid": true,
  "manifestName": "Example App",
  "manifestShortName": "Example",
  "faviconCount": 1,
  "favicons": [
    {
      "rel": "icon",
      "href": "/favicon.ico",
      "resolvedHref": "https://example.com/favicon.ico",
      "sizes": "any",
      "type": null
    }
  ],
  "manifestIconCount": 2,
  "manifestIcons": [
    { "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
  ],
  "hasName": true,
  "hasStartUrl": true,
  "hasDisplay": true,
  "hasThemeColor": true,
  "score": 100,
  "grade": "A",
  "issues": [],
  "recommendations": [],
  "error": null
}
```

### Security

The actor fetches only public HTTP and HTTPS URLs. It rejects URL credentials, localhost and private IP literals, and hostnames that resolve to private IPv4 or IPv6 ranges. Redirect targets are validated before following. Response bodies are capped at 2 MB.

### Pricing

Suggested pay-per-event pricing:

| Event | Suggested price |
| --- | ---: |
| Actor start | $0.005 |
| Page audited | $0.01 |

This keeps single-page checks inexpensive while supporting scheduled QA and batch workflows.

### FAQ

#### Does this check full PWA installability?

No. It checks manifest and icon readiness signals that can be verified from static HTML and manifest JSON. It does not run a browser, service worker, or Lighthouse audit.

#### Does it download every icon?

No. It extracts icon declarations and manifest icon records. It does not fetch each image file, which keeps runs fast and low maintenance.

#### Can I audit private staging sites?

No. The actor is designed for public unauthenticated pages only and blocks private network targets for SSRF safety.

# Actor input Schema

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

Public HTTP or HTTPS page URL to audit. Credentials and private network targets are rejected.

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

Request timeout for page and manifest fetches.

## Actor input object example

```json
{
  "startUrl": "https://example.com",
  "timeoutSeconds": 10
}
```

# 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"
};

// Run the Actor and wait for it to finish
const run = await client.actor("phoenix2810/web-app-manifest-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" }

# Run the Actor and wait for it to finish
run = client.actor("phoenix2810/web-app-manifest-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"
}' |
apify call phoenix2810/web-app-manifest-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/TZq0FZYaUgFXkLZIN/builds/wW0wgydKCr9VQNVA9/openapi.json