# 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:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 62 total users, 5 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?

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

## 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 all CSS sources for font declarations and font-loading links, and returns structured data about every font found including its source, format, and whether it is a Google Font, Adobe Font, or custom web font. 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, and classification flags |
| `fontFamiliesInCss` | Array of all font-family values found in CSS declarations |
| `googleFontsUrl` | The Google Fonts API URL if Google Fonts are used, null otherwise |
| `error` | 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",
            "isGoogleFont": false,
            "isSystemFont": false
        }
    ],
    "fontFamiliesInCss": ["SF Pro Display", "SF Pro Text", "SF Mono"],
    "googleFontsUrl": null,
    "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.

### 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 `<style>` blocks, `<link>` stylesheet references, and font preload links in the HTML. Fonts loaded entirely at runtime by JS may be missed.

**fontFamiliesInCss shows fonts that are not in the fonts array. Is this normal?**
Yes. The `fontFamiliesInCss` array includes all font-family values declared in CSS, including system font fallbacks like Arial, Helvetica, or system-ui. These are not loaded as web font files, so they do not appear in the `fonts` array. This is expected behavior and helps you see the complete font stack.

### Related SEO and website analysis tools

- [Favicon Extractor](https://apify.com/automation-lab/favicon-extractor) — extract favicon URLs from web pages including ICO, PNG, SVG, and Apple touch icons
- [Form Finder](https://apify.com/automation-lab/form-finder) — extract and analyze HTML forms from web pages with field details
- [Website Health Report](https://apify.com/automation-lab/website-health-report) — check website health including SSL, performance, and SEO basics
- [Tech Stack Detector](https://apify.com/automation-lab/tech-stack-detector) — identify technologies, frameworks, and tools used on any website

# Actor input Schema

## `urls` (type: `array`):

List of web page URLs to detect fonts.

## Actor input object example

```json
{
  "urls": [
    "https://www.google.com/",
    "https://en.wikipedia.org/wiki/Web_scraping",
    "https://www.apple.com/"
  ]
}
```

# Actor output Schema

## `overview` (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 = {
    "urls": [
        "https://www.google.com/",
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://www.apple.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/font-detector").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 = { "urls": [
        "https://www.google.com/",
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://www.apple.com/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/font-detector").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.google.com/",
    "https://en.wikipedia.org/wiki/Web_scraping",
    "https://www.apple.com/"
  ]
}' |
apify call automation-lab/font-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/font-detector"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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