# Google Fonts Live Query Actor (`scrapeai/google-livefonts`) Actor

Run a live public query against Google Fonts and return up to 100 normalized records without static fixtures.

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

## Pricing

from $1.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

### What does Google Fonts Live Query Actor do?

This Actor searches the **live public Google Fonts family metadata** for a phrase such as `sans serif`, then writes matching font families to an Apify dataset. It reads the public [Google Fonts](https://fonts.google.com/) metadata feed; it does not require a Google account or API key. Each record includes a specimen link, family category, language subsets, available styles, designers, modification date, and any popularity or trending values present in the feed.

Only families whose metadata matches at least one query term are returned. If fewer than `minItems` matching families are available, the run fails instead of padding the output with unrelated families or static examples.

### Why use Google Fonts Live Query Actor?

Use it to discover font families for design systems, compare styles and supported scripts, or monitor changes in the public catalog. Apify provides scheduled runs, dataset downloads, integrations, and API access. The result includes the query and retrieval timestamp so downstream workflows can distinguish a current catalog lookup from an older one.

### How to use Google Fonts Live Query Actor

1. Enter a search phrase in **Query**, such as `sans serif` or a designer name.
2. Leave **Maximum records** and **Minimum records** at 10 for a quick test. Lower the minimum if a narrow query is expected to match fewer families.
3. Run the Actor, then inspect the **Output** dataset. Open a specimen URL to view the family on Google Fonts.
4. Download the dataset as JSON, HTML, CSV, or Excel, or retrieve it through the Apify API.

### Input

| Field | Default | Purpose |
| --- | --- | --- |
| `query` | `sans serif` | Terms matched against family name, category, language subsets, and designer names. |
| `maxItems` | `10` | Maximum font families to return, up to 100. |
| `minItems` | `10` | Minimum number of matching live families required for a successful run. |
| `requestTimeoutSecs` | `30` | Timeout for the public metadata request. |
| `proxyConfiguration` | Disabled | Optional standard Apify proxy configuration when needed for ordinary connectivity. |

No login, CAPTCHA solving, or private account access is used.

```json
{"query":"sans serif","maxItems":10,"minItems":10}
```

### Output

The dataset contains **one real font family per item**, not a single page-level metadata record. A representative record from the default query is:

```json
{
  "serviceName": "Google Fonts",
  "query": "sans serif",
  "itemPosition": 1,
  "recordType": "fontFamily",
  "title": "Roboto",
  "url": "https://fonts.google.com/specimen/Roboto",
  "sourceUrl": "https://fonts.google.com/metadata/fonts",
  "sourceType": "google-fonts-metadata-live",
  "details": {
    "category": "Sans Serif",
    "subsets": ["latin", "greek"],
    "styles": ["400", "700"],
    "designers": ["Christian Robertson"],
    "openSource": true
  }
}
```

The example abbreviates array fields for readability; actual values come from the live feed and may change. Other fields can include `details.lastModified`, `details.popularity`, `details.trending`, `scrapedAt`, and the run duration.

### Data table

| Field | Meaning |
| --- | --- |
| `title` | Font family name. |
| `url` | Public Google Fonts specimen page. |
| `details.category` | Serif, Sans Serif, Display, Handwriting, or Monospace category when supplied. |
| `details.subsets` | Supported script/language subsets. |
| `details.styles` | Available style keys or weights from the feed. |
| `details.designers` | Designers credited by Google Fonts. |
| `details.lastModified` | Last-modified date reported by the feed. |
| `details.popularity`, `details.trending` | Source-provided ranking metadata, when present. |

### Pricing and cost estimation

The Actor charges **$0.00199 per dataset result**, plus the listed Actor Start event and platform usage costs. A default 10-result run has a result charge of $0.0199 before those additional costs. You can set a maximum run charge in Apify; smaller `maxItems` values help keep usage predictable.

### Tips and advanced options

Use a specific family, designer, category, or script term for a focused search. If the query is narrow, set `minItems` below 10 so a valid small result set is accepted. The Actor reads the current public feed once per run and does not invent records if it is unavailable. Local development can be checked with `apify validate-schema` and `apify run`.

### FAQ, disclaimers, and support

**Why did my run fail with zero results?** The public metadata request may have failed, or the phrase matched fewer families than `minItems`. Review the run log and try a broader term or a lower minimum. Do not interpret an access error as proof that the catalog is empty.

Use the data in accordance with Google Fonts terms and applicable law. This Actor extracts public font metadata, not personal or private account data. For questions or a source change, use the Actor's Issues tab.

# Actor input Schema

## `query` (type: `string`):

Query or text to send to the public Google Fonts source. The default is a working live-data query.

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

Maximum number of live records to return. Use 10 for a quick check or increase up to 100 when the source supports it.

## `minItems` (type: `integer`):

The Actor fails instead of adding static data when the live source returns fewer than this many records. Default is 10.

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

Timeout for each public live request.

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

Optional Apify Proxy or custom proxy configuration for public sources that rate-limit a local IP. Do not use this to bypass CAPTCHAs or access controls.

## Actor input object example

```json
{
  "query": "sans serif",
  "maxItems": 10,
  "minItems": 10,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "query": "sans serif"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeai/google-livefonts").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 = { "query": "sans serif" }

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

```

## MCP server setup

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

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/kLhcVlfx9rpZRVQP6/builds/iRMPkgSAax6B70DuR/openapi.json