# Font Detector (`automation-lab/font-detector`) Actor This actor detects web fonts used on web pages. It identifies Google Fonts, Adobe Fonts (Typekit), custom @font-face declarations, and font-family CSS properties. It parses inline styles, external stylesheets, and font preloading links. - **URL**: https://apify.com/automation-lab/font-detector.md - **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community) - **Categories:** Developer tools, SEO tools - **Features:** Limited permissions - **Stats:** 72 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.60 / 1,000 url analyzeds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Font Detector Detect web fonts loaded on web pages. Identify Google Fonts, Adobe Fonts, custom @font-face, and system fonts. ### What does Font Detector do? This actor detects **web fonts** used on web pages. It identifies Google Fonts, Adobe Fonts (Typekit), custom @font-face declarations, and font-family CSS properties. It parses inline styles, external stylesheets, and font preloading links. The actor loads each page, inspects inline CSS, linked stylesheets, nested CSS imports, and font preload links, and returns structured data about every font found. Font records include both the resolved font URL (when available) and the page or stylesheet URL that supplied the evidence. Non-fatal stylesheet failures are returned as explicit diagnostics instead of being silently ignored. Use it for design analysis, licensing audits, or performance optimization. ### Who is it for? - **Design analysis** -- identify fonts used on competitor websites to understand typography choices and design trends - **Font licensing** -- audit web font usage across your properties to ensure compliance with font license agreements - **Performance optimization** -- find unnecessary font loads that add weight and slow page rendering - **Brand consistency** -- verify that correct fonts are being served across all web properties and subdomains - **Accessibility review** -- check that readable, appropriately sized font families are used across your site ### Why use Font Detector? - **Multi-source detection** -- finds fonts from Google Fonts, Adobe Fonts (Typekit), custom @font-face, and CSS font-family declarations - **Structured output** -- get clean JSON with font families, sources, formats, and classification ready for analysis - **Batch processing** -- scan hundreds of URLs in a single run to audit fonts across entire websites or portfolios - **Format reporting** -- identifies font file formats (woff2, woff, ttf, otf) to verify optimal delivery - **API access** -- integrate font detection into design system monitoring or compliance workflows - **Pay-per-event pricing** -- only pay per page analyzed with no monthly fees ### Input parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `urls` | array | Yes | -- | List of web page URLs to detect fonts. Each URL is loaded and all font sources (CSS, preload links, Google Fonts API) are analyzed. | #### Example input ```json { "urls": [ "https://www.google.com", "https://en.wikipedia.org/wiki/Web_scraping", "https://www.apple.com" ] } ``` ### Recurring design and brand audits Font usage can drift after redesigns, A/B tests, or third-party widget changes. Save a list of important pages and schedule a monthly run to monitor loaded font families, Google Fonts usage, Adobe Fonts usage, and custom font formats across your site. Example monthly audit input: ```json { "urls": [ "https://www.example.com", "https://www.example.com/pricing", "https://www.example.com/blog" ] } ``` For a complete site-audit bundle, pair Font Detector with [Tech Stack Detector](https://apify.com/automation-lab/tech-stack-detector) for technology changes, [Sitemap URL Extractor](https://apify.com/automation-lab/sitemap-url-extractor) to maintain the page list, [SSL Certificate Checker](https://apify.com/automation-lab/ssl-certificate-checker), and [Domain Age Checker](https://apify.com/automation-lab/domain-age-checker). ### Output fields Each URL produces one record with the following fields: | Field | Description | |-------|-------------| | `url` | The original URL provided in the input | | `title` | The page title | | `fontCount` | Total number of web fonts detected | | `googleFontCount` | Number of fonts loaded from Google Fonts | | `adobeFontCount` | Number of fonts loaded from Adobe Fonts (Typekit) | | `customFontCount` | Number of fonts loaded via custom @font-face declarations | | `fonts` | Array of font objects with family, source, format, resolved font `url`, evidence `sourceUrl`, and classification flags | | `fontFamiliesInCss` | Array of all font-family values found in inline and traversed external CSS declarations | | `googleFontsUrl` | The first Google Fonts API URL if Google Fonts are used, null otherwise | | `pageStatusCode` | HTTP status returned by the page, when available | | `stylesheetsAnalyzed` | Number of unique linked or imported stylesheets requested | | `partial` | True when a stylesheet failed or a traversal bound was reached | | `diagnostics` | Structured page/stylesheet HTTP errors, fetch errors, and traversal-limit notices | | `error` | Page-level error message if analysis failed, null otherwise | | `checkedAt` | ISO 8601 timestamp of the analysis | ### Output example ```json { "url": "https://www.apple.com", "title": "Apple", "fontCount": 3, "googleFontCount": 0, "adobeFontCount": 0, "customFontCount": 3, "fonts": [ { "family": "SF Pro Display", "source": "font-face", "format": "woff2", "url": "https://www.apple.com/fonts/sf-pro-display.woff2", "sourceUrl": "https://www.apple.com/assets/main.css", "isGoogleFont": false, "isSystemFont": false } ], "fontFamiliesInCss": ["SF Pro Display", "SF Pro Text", "SF Mono"], "googleFontsUrl": null, "pageStatusCode": 200, "stylesheetsAnalyzed": 4, "partial": false, "diagnostics": [], "error": null, "checkedAt": "2026-03-01T12:00:00.000Z" } ``` ### How to detect fonts on a website 1. Go to the [Font Detector](https://apify.com/automation-lab/font-detector) page on Apify Store. 2. Enter one or more website URLs into the **URLs** field. 3. Click **Start** and wait for the run to finish. 4. Review the results to see all fonts detected on each page, including Google Fonts, Adobe Fonts, and custom @font-face declarations. 5. Download your data in JSON, CSV, or Excel format. ### How much does it cost to detect website fonts? Font Detector uses Apify's pay-per-event pricing. You only pay for what you use. | Event | Price | Description | |-------|-------|-------------| | Start | $0.035 | One-time per run | | URL analyzed | $0.001 | Per page analyzed | **Cost examples:** - 10 pages: $0.035 + 10 x $0.001 = **$0.045** - 100 pages: $0.035 + 100 x $0.001 = **$0.135** - 1,000 pages: $0.035 + 1,000 x $0.001 = **$1.035** ### API usage You can start Font Detector programmatically using the Apify API. Replace `YOUR_TOKEN` with your [Apify API token](https://console.apify.com/settings/integrations). #### Node.js ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_TOKEN' }); const run = await client.actor('automation-lab/font-detector').call({ urls: ['https://www.apple.com', 'https://www.google.com'], }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient('YOUR_TOKEN') run = client.actor('automation-lab/font-detector').call(run_input={ 'urls': ['https://www.apple.com', 'https://www.google.com'], }) items = client.dataset(run['defaultDatasetId']).list_items().items print(items) ``` #### cURL ```bash curl "https://api.apify.com/v2/acts/automation-lab~font-detector/runs" \ -X POST \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_TOKEN" \ -d '{"urls": ["https://www.apple.com", "https://www.google.com"]}' ``` ### Use with AI agents via MCP [Font Detector](https://apify.com/automation-lab/font-detector) is available as a tool for AI assistants via the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp). #### Setup for Claude Code ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/font-detector" ``` #### Setup for Claude Desktop, Cursor, or VS Code ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=automation-lab/font-detector" } } } ``` #### Example prompts - "What fonts does apple.com use?" - "Detect all fonts loaded on this website" Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp). ### Integrations Connect Font Detector with other tools using [Apify integrations](https://apify.com/integrations). Export results to Google Sheets for font inventory tracking, send Slack alerts when unauthorized fonts appear on your pages, trigger Make or Zapier workflows for licensing compliance reports, push data to n8n for custom analytics pipelines, or configure webhooks to monitor font usage after deployments. ### CSS traversal and partial results Font Detector requests at most **20 unique stylesheets per page** and follows `@import` rules to a maximum depth of **3**. Page requests time out after 15 seconds and stylesheet requests after 8 seconds. These conservative bounds prevent import loops and keep batch runs within the default 300-second limit. A successful page can still have `partial: true`. Inspect `diagnostics` to see the exact stylesheet URL and HTTP/fetch/limit reason. A non-2xx page response sets `error` and `pageStatusCode` instead of returning a misleading successful zero-font audit. JavaScript-injected styles and fonts remain outside this static HTML/CSS analysis. ### Tips and best practices - **Check the format field** to ensure fonts are served as woff2, which provides the best compression and broadest modern browser support. - **Monitor fontCount over time** to catch font bloat -- too many font files slow down page rendering due to multiple network requests. - **Use googleFontsUrl** to see the exact Google Fonts API call a site uses, which tells you weights and subsets being loaded. - **Compare fontFamiliesInCss with actual fonts loaded** to find CSS declarations referencing fonts that are not actually loaded (fallback-only families). - **Combine with CSS Stats Analyzer** to get a complete picture of both font loading and overall CSS typography patterns. ### Legality This tool analyzes publicly accessible web content. Automated analysis of public web resources is standard practice in SEO and web development. Always respect robots.txt directives and rate limits when analyzing third-party websites. For personal data processing, ensure compliance with applicable privacy regulations. ### FAQ **What font sources does the actor detect?** The actor detects Google Fonts (via the Google Fonts API), Adobe Fonts/Typekit, custom @font-face declarations in CSS, font preloading via link tags, and font-family properties in stylesheets. **Does the actor distinguish between loaded and declared fonts?** Yes. The `fonts` array shows actually loaded fonts (from @font-face, Google Fonts, or Adobe Fonts), while `fontFamiliesInCss` shows all font-family values declared in CSS, which may include system font fallbacks not loaded as web fonts. **Can I detect system fonts used as fallbacks?** The `fontFamiliesInCss` array includes all font-family values found in CSS, including system fonts like Arial, Helvetica, or system-ui. The `isSystemFont` field in the fonts array indicates whether a detected font is a system font. **The actor found zero fonts but the website clearly uses custom web fonts. Why?** If fonts are loaded dynamically via JavaScript (e.g., using the CSS Font Loading API or injected stylesheet links), they may not appear in the initial HTML source that the actor parses. The actor inspects CSS from `