Pricing

Pay per usage

Web App Manifest Auditor

Audit one public page for web app manifest and favicon readiness. Checks manifest JSON, icons, name, start_url, display, theme_color, score, and recommendations.

Pricing

Pay per usage

Rating

0.0

(0)

Developer

Sanskar Jaiswal

Actor stats

Bookmarked

Total users

Monthly active users

12 days ago

Last modified

Dockerfile

FROM apify/actor-node:22

COPY package*.json ./
RUN npm --quiet set progress=false && npm install --omit=dev

COPY . ./

CMD ["npm", "start"]

package.json

{
  "name": "web-app-manifest-auditor",
  "version": "0.1.0",
  "description": "Apify Actor that audits public pages for web app manifest and favicon readiness.",
  "type": "module",
  "private": true,
  "main": "src/main.js",
  "scripts": {
    "start": "node src/main.js",
    "test": "node --test test/*.test.js",
    "lint": "node --check src/main.js"
  },
  "dependencies": {
    "apify": "^3.4.5"
  },
  "devDependencies": {}
}

.actor/actor.json

{
  "actorSpecification": 1,
  "name": "web-app-manifest-auditor",
  "title": "Web App Manifest Auditor",
  "description": "Audit one public page for web app manifest and favicon readiness, including manifest fields, icons, theme color, and installability signals.",
  "version": "0.1",
  "buildTag": "latest",
  "meta": {
    "templateId": "js-start"
  },
  "input": "./input_schema.json",
  "output": "./output_schema.json",
  "storages": {
    "dataset": "./dataset_schema.json"
  },
  "dockerfile": "./Dockerfile",
  "defaultRunOptions": {
    "build": "latest",
    "timeoutSecs": 60,
    "memoryMbytes": 512
  }
}

.actor/dataset_schema.json

{
  "actorSpecification": 1,
  "views": {
    "overview": {
      "title": "Manifest audits",
      "transformation": {
        "fields": ["inputUrl", "normalizedInputUrl", "status", "ok", "manifestUrl", "manifestStatus", "manifestValid", "faviconCount", "manifestIconCount", "hasName", "hasStartUrl", "hasDisplay", "hasThemeColor", "score", "grade", "issues", "recommendations", "checkedAt"]
      },
      "display": {
        "component": "table",
        "properties": {
          "inputUrl": { "label": "Input URL", "format": "link" },
          "normalizedInputUrl": { "label": "Normalized URL", "format": "link" },
          "status": { "label": "HTTP status" },
          "ok": { "label": "OK" },
          "manifestUrl": { "label": "Manifest URL", "format": "link" },
          "manifestStatus": { "label": "Manifest status" },
          "manifestValid": { "label": "Manifest valid" },
          "faviconCount": { "label": "Favicons" },
          "manifestIconCount": { "label": "Manifest icons" },
          "hasName": { "label": "Has name" },
          "hasStartUrl": { "label": "Has start_url" },
          "hasDisplay": { "label": "Has display" },
          "hasThemeColor": { "label": "Has theme color" },
          "score": { "label": "Score" },
          "grade": { "label": "Grade" },
          "issues": { "label": "Issues" },
          "recommendations": { "label": "Recommendations" },
          "checkedAt": { "label": "Checked at", "format": "date" }
        }
      }
    }
  },
  "fields": {
    "inputUrl": { "type": "string" },
    "normalizedInputUrl": { "type": "string" },
    "status": { "type": ["integer", "null"] },
    "ok": { "type": "boolean" },
    "manifestUrl": { "type": ["string", "null"] },
    "manifestStatus": { "type": ["integer", "null"] },
    "manifestValid": { "type": "boolean" },
    "faviconCount": { "type": "integer" },
    "manifestIconCount": { "type": "integer" },
    "hasName": { "type": "boolean" },
    "hasStartUrl": { "type": "boolean" },
    "hasDisplay": { "type": "boolean" },
    "hasThemeColor": { "type": "boolean" },
    "score": { "type": "integer" },
    "grade": { "type": "string" },
    "issues": { "type": "array", "items": { "type": "string" } },
    "recommendations": { "type": "array", "items": { "type": "string" } },
    "checkedAt": { "type": "string" }
  }
}

.actor/input_schema.json

{
  "title": "Web App Manifest Auditor Input",
  "description": "Enter one public HTTP or HTTPS page URL to audit its web app manifest and favicon readiness.",
  "type": "object",
  "schemaVersion": 1,
  "properties": {
    "startUrl": {
      "title": "Page URL",
      "type": "string",
      "description": "Public HTTP or HTTPS page URL to audit. Credentials and private network targets are rejected.",
      "editor": "textfield",
      "prefill": "https://example.com"
    },
    "timeoutSeconds": {
      "title": "Timeout seconds",
      "type": "integer",
      "description": "Request timeout for page and manifest fetches.",
      "editor": "number",
      "default": 10,
      "minimum": 3,
      "maximum": 30
    }
  },
  "required": ["startUrl"]
}

.actor/output_schema.json

{
  "actorOutputSchemaVersion": 1,
  "title": "Web App Manifest Auditor Output",
  "properties": {
    "results": {
      "type": "string",
      "title": "Manifest audits",
      "template": "{{links.apiDefaultDatasetUrl}}/items"
    }
  }
}

src/main.js

1import { Actor } from 'apify';
2import dns from 'node:dns/promises';
3import net from 'node:net';
4import { fileURLToPath } from 'node:url';
5
6const USER_AGENT = 'WebAppManifestAuditor/0.1 (+https://apify.com)';
7const MAX_BODY_BYTES = 2_000_000;
8
9function isPrivateIPv4(ip) {
10  const parts = ip.split('.').map(Number);
11  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n))) return false;
12  const [a, b] = parts;
13  return a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || a === 127 || a === 0 || (a === 169 && b === 254);
14}
15
16function isPrivateIPv6(ip) {
17  const normalized = ip.toLowerCase();
18  return normalized === '::1' || normalized.startsWith('fc') || normalized.startsWith('fd') || normalized.startsWith('fe80:');
19}
20
21export async function normalizeAndValidateUrl(rawUrl) {
22  if (!rawUrl || typeof rawUrl !== 'string') throw new Error('startUrl is required');
23  if (/^[a-z][a-z0-9+.-]*:/i.test(rawUrl) && !/^https?:\/\//i.test(rawUrl)) throw new Error('Only HTTP and HTTPS URLs are supported');
24
25  const withScheme = /^https?:\/\//i.test(rawUrl) ? rawUrl : `https://${rawUrl}`;
26  const url = new URL(withScheme);
27  if (!['http:', 'https:'].includes(url.protocol)) throw new Error('Only HTTP and HTTPS URLs are supported');
28  if (!url.hostname || url.username || url.password) throw new Error('URL must be public and must not include credentials');
29
30  const literalType = net.isIP(url.hostname);
31  if (literalType === 4 && isPrivateIPv4(url.hostname)) throw new Error('Private IPv4 targets are blocked');
32  if (literalType === 6 && isPrivateIPv6(url.hostname)) throw new Error('Private IPv6 targets are blocked');
33
34  const records = literalType ? [{ address: url.hostname, family: literalType }] : await dns.lookup(url.hostname, { all: true });
35  for (const record of records) {
36    if (record.family === 4 && isPrivateIPv4(record.address)) throw new Error('DNS resolves to a private IPv4 address; blocked for SSRF safety');
37    if (record.family === 6 && isPrivateIPv6(record.address)) throw new Error('DNS resolves to a private IPv6 address; blocked for SSRF safety');
38  }
39  return url;
40}
41
42function clampInteger(value, fallback, min, max) {
43  const parsed = Number(value);
44  if (!Number.isFinite(parsed)) return fallback;
45  return Math.min(Math.max(Math.trunc(parsed), min), max);
46}
47
48function attrsFromTag(tag) {
49  const attrs = {};
50  for (const match of tag.matchAll(/([\w:-]+)\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/g)) {
51    attrs[match[1].toLowerCase()] = match[2].replace(/^['"]|['"]$/g, '').trim();
52  }
53  return attrs;
54}
55
56export function parseManifestLinks(html, baseUrl) {
57  const manifests = [];
58  const favicons = [];
59  for (const match of html.matchAll(/<link\b[^>]*>/gi)) {
60    const attrs = attrsFromTag(match[0]);
61    const rels = (attrs.rel || '').toLowerCase().split(/\s+/);
62    const href = attrs.href || '';
63    let resolvedHref = null;
64    try { resolvedHref = href ? new URL(href, baseUrl).href : null; } catch {}
65    if (rels.includes('manifest')) manifests.push({ href, resolvedHref });
66    if (rels.some((rel) => ['icon', 'shortcut', 'apple-touch-icon', 'mask-icon'].includes(rel))) {
67      favicons.push({ rel: attrs.rel || '', href, resolvedHref, sizes: attrs.sizes || null, type: attrs.type || null });
68    }
69  }
70  return { manifests, favicons };
71}
72
73function manifestSignals(manifest) {
74  const icons = Array.isArray(manifest?.icons) ? manifest.icons : [];
75  return {
76    hasName: Boolean(manifest?.name || manifest?.short_name),
77    hasStartUrl: Boolean(manifest?.start_url),
78    hasDisplay: Boolean(manifest?.display),
79    hasThemeColor: Boolean(manifest?.theme_color),
80    manifestIconCount: icons.length,
81    icons,
82  };
83}
84
85function scoreAudit({ status, manifestUrl, manifestStatus, manifestValid, signals, faviconCount, error }) {
86  const issues = [];
87  const recommendations = [];
88  let score = 100;
89
90  if (error) return { score: 0, grade: 'F', issues: [error], recommendations: ['Verify the URL is public, reachable, and returns HTML.'] };
91  if (!status || status >= 400) {
92    score -= 35;
93    issues.push(`HTTP status is ${status || 'unknown'}`);
94    recommendations.push('Audit a live 2xx HTML page.');
95  }
96  if (!manifestUrl) {
97    score -= 35;
98    issues.push('No web app manifest link found');
99    recommendations.push('Add <link rel="manifest" href="/site.webmanifest"> in the page head.');
100  } else if (!manifestValid) {
101    score -= 30;
102    issues.push(`Manifest was not valid JSON or not reachable (status ${manifestStatus || 'unknown'})`);
103    recommendations.push('Serve a valid JSON web app manifest from a public HTTPS URL.');
104  }
105  if (faviconCount === 0) {
106    score -= 20;
107    issues.push('No favicon or touch icon links found');
108    recommendations.push('Add favicon and apple-touch-icon links for browser tabs and saved shortcuts.');
109  }
110  if (manifestValid) {
111    if (!signals.hasName) { score -= 15; issues.push('Manifest is missing name or short_name'); recommendations.push('Add name and short_name to the manifest.'); }
112    if (!signals.hasStartUrl) { score -= 10; issues.push('Manifest is missing start_url'); recommendations.push('Add start_url to control launch behavior.'); }
113    if (!signals.hasDisplay) { score -= 10; issues.push('Manifest is missing display'); recommendations.push('Add display, commonly standalone or minimal-ui.'); }
114    if (!signals.hasThemeColor) { score -= 5; issues.push('Manifest is missing theme_color'); recommendations.push('Add theme_color for browser UI integration.'); }
115    if (signals.manifestIconCount === 0) { score -= 15; issues.push('Manifest has no icons'); recommendations.push('Add at least 192x192 and 512x512 icons.'); }
116  }
117
118  const bounded = Math.max(0, score);
119  const grade = bounded >= 90 ? 'A' : bounded >= 75 ? 'B' : bounded >= 60 ? 'C' : bounded >= 45 ? 'D' : 'F';
120  return { score: bounded, grade, issues: [...new Set(issues)], recommendations: [...new Set(recommendations)] };
121}
122
123async function fetchText(url, timeoutSeconds, accept) {
124  await normalizeAndValidateUrl(url.href);
125  const controller = new AbortController();
126  const timeout = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
127  try {
128    const response = await fetch(url, { redirect: 'manual', signal: controller.signal, headers: { 'user-agent': USER_AGENT, accept } });
129    const location = response.headers.get('location');
130    if (location && response.status >= 300 && response.status < 400) {
131      const next = new URL(location, url.href);
132      await normalizeAndValidateUrl(next.href);
133      return fetchText(next, timeoutSeconds, accept);
134    }
135    return { status: response.status, finalUrl: url.href, contentType: response.headers.get('content-type') || '', body: (await response.text()).slice(0, MAX_BODY_BYTES) };
136  } finally {
137    clearTimeout(timeout);
138  }
139}
140
141export async function auditWebAppManifest(input) {
142  const startUrl = await normalizeAndValidateUrl(input.startUrl);
143  const timeoutSeconds = clampInteger(input.timeoutSeconds, 10, 3, 30);
144  const checkedAt = new Date().toISOString();
145  let page = null;
146  let manifestFetch = null;
147  let manifest = null;
148  let error = null;
149
150  try {
151    page = await fetchText(startUrl, timeoutSeconds, 'text/html,*/*;q=0.1');
152    const parsed = parseManifestLinks(page.body, page.finalUrl);
153    const manifestUrl = parsed.manifests[0]?.resolvedHref;
154    if (manifestUrl) {
155      manifestFetch = await fetchText(new URL(manifestUrl), timeoutSeconds, 'application/manifest+json,application/json,*/*;q=0.1');
156      if (manifestFetch.status >= 200 && manifestFetch.status < 400) manifest = JSON.parse(manifestFetch.body);
157    }
158  } catch (caught) {
159    error = caught.message;
160  }
161
162  const finalUrl = page?.finalUrl || startUrl.href;
163  const parsed = parseManifestLinks(page?.body || '', finalUrl);
164  const signals = manifestSignals(manifest);
165  const manifestUrl = parsed.manifests[0]?.resolvedHref || null;
166  const manifestValid = Boolean(manifest);
167  const scored = scoreAudit({ status: page?.status, manifestUrl, manifestStatus: manifestFetch?.status, manifestValid, signals, faviconCount: parsed.favicons.length, error });
168
169  return {
170    inputUrl: input.startUrl,
171    normalizedInputUrl: startUrl.href,
172    finalUrl,
173    status: page?.status || null,
174    ok: !error && page?.status >= 200 && page?.status < 400,
175    checkedAt,
176    manifestUrl,
177    manifestStatus: manifestFetch?.status || null,
178    manifestValid,
179    manifestName: manifest?.name || null,
180    manifestShortName: manifest?.short_name || null,
181    faviconCount: parsed.favicons.length,
182    favicons: parsed.favicons,
183    manifestIconCount: signals.manifestIconCount,
184    manifestIcons: signals.icons,
185    hasName: signals.hasName,
186    hasStartUrl: signals.hasStartUrl,
187    hasDisplay: signals.hasDisplay,
188    hasThemeColor: signals.hasThemeColor,
189    score: scored.score,
190    grade: scored.grade,
191    issues: scored.issues,
192    recommendations: scored.recommendations,
193    error,
194  };
195}
196
197const isExecutedDirectly = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
198
199if (process.env.NODE_ENV !== 'test' && isExecutedDirectly) {
200  await Actor.init();
201  try {
202    const input = await Actor.getInput();
203    const result = await auditWebAppManifest(input || {});
204    await Actor.pushData(result);
205    await Actor.setValue('OUTPUT', result);
206    Actor.log.info('Web app manifest audit complete', { finalUrl: result.finalUrl, score: result.score, grade: result.grade });
207  } finally {
208    await Actor.exit();
209  }
210}

test/main.test.js

1import assert from 'node:assert/strict';
2import { test } from 'node:test';
3import { auditWebAppManifest, normalizeAndValidateUrl, parseManifestLinks } from '../src/main.js';
4
5test('blocks non-public and credentialed targets', async () => {
6  await assert.rejects(() => normalizeAndValidateUrl('ftp://example.com'), /Only HTTP/);
7  await assert.rejects(() => normalizeAndValidateUrl('https://user:pass@example.com'), /credentials/);
8  await assert.rejects(() => normalizeAndValidateUrl('http://127.0.0.1'), /Private IPv4/);
9});
10
11test('parses manifest and icon links', () => {
12  const parsed = parseManifestLinks(`
13    <link rel="manifest" href="/site.webmanifest">
14    <link rel="icon" href="/favicon.ico" sizes="any">
15    <link rel="apple-touch-icon" href="/apple.png">
16  `, 'https://example.com/page');
17  assert.equal(parsed.manifests[0].resolvedHref, 'https://example.com/site.webmanifest');
18  assert.equal(parsed.favicons.length, 2);
19});
20
21test('audits manifest readiness', async () => {
22  const originalFetch = globalThis.fetch;
23  globalThis.fetch = async (url) => {
24    const href = String(url);
25    if (href.endsWith('/site.webmanifest')) {
26      return new Response(JSON.stringify({
27        name: 'Example App',
28        short_name: 'Example',
29        start_url: '/',
30        display: 'standalone',
31        theme_color: '#ffffff',
32        icons: [{ src: '/icon-192.png', sizes: '192x192', type: 'image/png' }],
33      }), { status: 200, headers: { 'content-type': 'application/manifest+json' } });
34    }
35    return new Response(`
36      <html><head>
37        <link rel="manifest" href="/site.webmanifest">
38        <link rel="icon" href="/favicon.ico" sizes="any">
39      </head></html>
40    `, { status: 200, headers: { 'content-type': 'text/html' } });
41  };
42
43  try {
44    const result = await auditWebAppManifest({ startUrl: 'https://example.com/page' });
45    assert.equal(result.manifestValid, true);
46    assert.equal(result.manifestUrl, 'https://example.com/site.webmanifest');
47    assert.equal(result.faviconCount, 1);
48    assert.equal(result.manifestIconCount, 1);
49    assert.equal(result.grade, 'A');
50  } finally {
51    globalThis.fetch = originalFetch;
52  }
53});
54
55test('reports missing manifest and favicon issues', async () => {
56  const originalFetch = globalThis.fetch;
57  globalThis.fetch = async () => new Response('<html><head></head></html>', { status: 200, headers: { 'content-type': 'text/html' } });
58
59  try {
60    const result = await auditWebAppManifest({ startUrl: 'https://example.com/page' });
61    assert.equal(result.manifestValid, false);
62    assert.equal(result.faviconCount, 0);
63    assert.match(result.issues.join(' '), /No web app manifest/);
64    assert.match(result.issues.join(' '), /No favicon/);
65  } finally {
66    globalThis.fetch = originalFetch;
67  }
68});

Favicon Extractor

automation-lab/favicon-extractor

This actor extracts all favicon references from web pages. It finds standard favicon links, Apple touch icons, SVG icons, mask icons, and checks for the default `/favicon.ico` fallback. It also detects web app manifest references. Each favicon entry includes the URL, format, sizes, and rel...

Stas Persiianenko

Favicon & Brand Asset Extractor — Logos & Icons

q_services/favicon-brand-asset-extractor

Extract favicons, apple-touch-icons, web manifest, theme-color and brand images from any list of sites. Great for CRM and directory enrichment.

Q Services

Favicon & Brand Asset Checker

s3nafps/favicon-brand-asset-checker

Find favicons, Apple touch icons, web manifests, manifest icons, and Open Graph images from public websites. Export clean brand asset URLs as JSON or CSV.

mohamed senator

Favicon Extractor API — All Icons, Sizes & Types from a URL

eliai/webpage-favicon-extractor

Favicon extractor API. Input: startUrls. Output: JSON per site listing every declared icon — favicon, apple-touch-icon, mask-icon, and Web App Manifest icons — with absolute URL, sizes, and MIME type. Cheap pay-per-result: $0.01 per page scanned.

Anthony Snider

Website Brand Asset Extractor

snapperwapper/website-brand-asset-extractor

Extract favicons, app icons, logo candidates, social images, manifest assets, brand name, and theme color from up to 1,000 websites.

snapperwapper

Favicon Checker

scrappy_garden/favicon-checker

Check if a website has a valid favicon and icon setup for SEO and UX. Detects <link rel=icon> tags, default /favicon.ico, Apple touch icons, mask-icon, and web manifest icons. Validates URLs, HTTP status codes, content types, and reports missing/broken icons.

Bikram Adhikari

Favicon & Brand Asset Extractor

santamaria-automations/favicon-extractor

Extract favicons, Apple touch icons, PWA manifest icons, logos, and brand colors from any website. Perfect for link preview generation, brand research, directory building, and ML training datasets. Export data, run via API, schedule and monitor runs, or integrate with other tools.

NanoScrape

App Store Ratings Scraper

maximedupre/app-store-ratings-scraper

Get Google Play and Apple App Store ratings, review counts, prices, categories, developers, icons, screenshots, and app metadata from app URLs or IDs.

Maxime Dupré

Chrome Extension Scraper

easyapi/chrome-extension-scraper

Scrape Chrome Web Store extensions data including ratings, reviews, user counts, descriptions, and manifest details. Perfect for market research, competitor analysis, and tracking extension trends.

EasyApi

5.0

App Store App Data Scraper

xam1go/app-store-app-data-scraper

Scrape App Store (iOS) app data into structured, LLM-ready JSON. Search apps by keyword or fetch details by App ID: title, developer, rating, price, category, version and description. Ideal for ASO, app market research and competitor intelligence. Pay per app.