# Google Fonts Scraper (`googleapi/google-fonts-scraper`) Actor

Search the public Google Fonts catalog and optionally extract family descriptions, designers, style variants, variable axes, language coverage, license information, and CSS2 embed URLs.

- **URL**: https://apify.com/googleapi/google-fonts-scraper.md
- **Developed by:** [Google API](https://apify.com/googleapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Find font families in the public Google Fonts catalog and collect details about the families that interest you. Search by family name or provide catalog and specimen URLs. Optional detail collection adds public designer, style, language, glyph, and license information.

### How to use

1. Enter family names or phrases in `queries`, or provide Google Fonts URLs in `startUrls`.
2. Set the maximum number of unique font families to return.
3. To collect extended family information, enable `includeDetails` and set `maxDetailItems`.
4. Run the Actor and review or export the font records from the dataset.

Example search:

```json
{
  "queries": ["Roboto Mono", "humanist sans serif"],
  "maxItems": 25,
  "maxPages": 2
}
```

Example with family details:

```json
{
  "startUrls": [
    { "url": "https://fonts.google.com/specimen/Roboto+Mono" }
  ],
  "includeDetails": true,
  "maxDetailItems": 1
}
```

### Input

| Input | Description | Default |
|---|---|---:|
| `queries` | Font family names or phrases to search in Google Fonts. | — |
| `startUrls` | Google Fonts catalog, family specimen, or related family page URLs. | — |
| `maxItems` | Maximum unique font family records across the run (1–500). | 25 |
| `page` | Starting position in the combined list of supplied URLs and searches (1–100). | 1 |
| `maxPages` | Maximum number of entries in that list to inspect, starting at `page` (1–100). | 10 |
| `includeDetails` | Include public specimen, About, license, and glyph details for selected families. | `false` |
| `maxDetailItems` | Maximum families to enrich when details are enabled (0–50). | 5 |

Google Fonts results are not numbered pages in this Actor. `page` and `maxPages` apply to the ordered list of URLs and searches. Family details can require up to four additional public pages per selected family.

### Output

Each dataset item represents a font family. `fontFamily` is the required family name. Catalog results can also include its specimen URL, slug, designer names, variable-font status, and variable-axis count.

When `includeDetails` is enabled, available fields can include:

- **Family and styles:** style names and details, variable axes, and taxonomy labels.
- **Designers and project links:** designer profiles, related families, contribution links, and repository links.
- **About information:** public family description and last-updated wording.
- **Language and glyph coverage:** language and region counts, supported language names, and displayed glyph groups.
- **License information:** license name, version, effective date, statement, full text, and sections.
- **Usage indicators:** Google Fonts usage and featured-website counts as displayed text.

These details vary by family and by what Google Fonts publishes. Values such as usage counts retain their displayed wording; the Actor does not turn them into an exact numeric estimate.

Example dataset item:

```json
{
  "fontFamily": "Example Sans",
  "family": "Example Sans",
  "slug": "Example+Sans",
  "specimenUrl": "https://fonts.google.com/specimen/Example+Sans",
  "designerNames": ["Example Designer"],
  "isVariable": true,
  "variableAxisCount": 2
}
```

The Output tab shows the available result fields. The run output includes links to the dataset and run summary.

### Limits and responsible use

Results depend on the public Google Fonts catalog. Detail collection can increase run time because it reads additional family pages. This Actor is not affiliated with Google.

# Actor input Schema

## `startUrls` (type: `array`):

Optional Google Fonts catalog or family page URLs. Only HTTPS fonts.google.com catalog and specimen pages are accepted.

## `queries` (type: `array`):

Family names or text to search on Google Fonts. Each query is opened as a public catalog search.

## `maxItems` (type: `integer`):

Maximum number of unique font family records across all requested pages.

## `page` (type: `integer`):

One-based starting position in the combined list of startUrls followed by queries. Google Fonts catalog pages are not numbered by this Actor.

## `maxPages` (type: `integer`):

Maximum number of supplied or generated catalog pages to inspect, starting at the selected source position.

## `includeDetails` (type: `boolean`):

Also fetch each selected family's public specimen, About, license, and glyph coverage pages (up to four pages per family). Disabled by default to limit requests.

## `maxDetailItems` (type: `integer`):

Maximum number of result families whose specimen, About, license, and glyph pages are fetched when details are enabled.

## `requestTimeoutSecs` (type: `integer`):

Maximum time allowed for one public page request.

## `proxyConfiguration` (type: `object`):

Accepted for input compatibility. The direct HTTP transport does not route requests through Apify proxies.

## Actor input object example

```json
{
  "maxItems": 25,
  "page": 1,
  "maxPages": 10,
  "includeDetails": false,
  "maxDetailItems": 5,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `health` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("googleapi/google-fonts-scraper").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("googleapi/google-fonts-scraper").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 '{}' |
apify call googleapi/google-fonts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,googleapi/google-fonts-scraper"
        }
    }
}
```

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/CrPCUl5oPCq7nNZGf/builds/O8FG3h1myJS8eW7xN/openapi.json