# Google News Scraper | $1.49 / 1k | (`glasswing/news-headlines-scraper`) Actor

Turn Google News into structured rows. Search any keyword, topic or publication and get headline, publisher, publish time, snippet and link. Metadata only, never article text. Export to CSV, JSON or Excel.

- **URL**: https://apify.com/glasswing/news-headlines-scraper.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** News, SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does Google News Scraper do?

**Get a clean, deduplicated table of news headlines for any keyword, topic or publication — headline, publisher, publication time, snippet and link, one row per article.** PR and comms teams use it to catch brand mentions the day they appear, analysts use it to measure share of coverage, and AI engineers use it to keep an agent supplied with fresh, structured news.

Use it to **scrape Google News headlines** by search term, by topic section (Technology, Business, Health...), by publication, or from any [Google News](https://news.google.com/) URL you copied from your browser. It works as a **Google News API alternative**: no key to request, no quota to negotiate, no browser to drive. One feed request returns up to about 100 articles, so a run finishes in seconds and costs a fraction of a cent.

✨ **Try it:** press **Start** with the prefilled input. Twenty articles land in under 10 seconds.

⚠️ **Read this before you buy:** only the **headline, snippet, link and metadata** that Google News itself publishes in its feed are returned — **never the body text of an article**. If you need full article text, follow the `link` yourself under the publisher's own terms.

### Use cases: brand monitoring, market research, news datasets for AI agents

- 📣 **PR and comms teams monitoring a brand.** Schedule an hourly run on your company, your executives and your competitors, and push every new headline into Slack or a spreadsheet so nobody finds out about coverage from a customer.
- 📊 **Market researchers and analysts.** Pull the last few weeks of coverage for an industry or a company, then count articles per publisher, per week or per country to show where a story is actually landing.
- 🤖 **AI engineers building a news dataset for an agent or RAG pipeline.** Hand an LLM a fresh, deduplicated list of headlines with publisher names and ISO timestamps instead of raw HTML — every row carries a stable `guid` so a scheduled run only adds what is new.
- 💹 **Investment and risk teams watching events.** Track a ticker, a commodity or a regulator across country editions and flag the first mention of a keyword such as a recall, a lawsuit or a leadership change.
- ✍️ **Editorial and SEO teams planning content.** Watch a topic section or a single publication to see what is being covered right now, and which angles are saturated before you commission a piece.
- 🏢 **Agencies reporting to clients.** Run one job per client domain or brand name, export to Excel, and drop the coverage list straight into a monthly report.

The Actor does not log in, does not read paywalled content and does not download article pages.

### What data you get

One row per article. The **Articles** view shows the first block; the **All fields** view adds feed context and identifiers.

**The article itself**

| Field | Type | What it tells you |
|---|---|---|
| `title` | string | Headline exactly as Google News publishes it. Google usually appends ` - Publisher`. |
| `source` | string | Publisher name, e.g. `Reuters`. |
| `publishedAt` | string | Publication time in ISO 8601 UTC, converted from the feed's RFC-822 `pubDate`. |
| `link` | string | Google News article link. Opening it forwards to the publisher's article. Same value as `url`. |
| `snippet` | string | Plain-text description from the feed. Never article body text. |
| `imageUrl` | string | Image URL when the feed carries one. Search and topic feeds usually carry none. |

**Identifiers and publisher**

| Field | Type | What it tells you |
|---|---|---|
| `guid` | string | Google News item identifier; stable across runs, so it is the right key for deduplication. |
| `sourceUrl` | string | Publisher home page, from the feed's `source` element. |
| `publisherUrl` | string | Article URL on the publisher's own site. Only filled when **Resolve publisher URL** is on and the link uses Google's older, decodable format (see Limitations). |

**Feed context and run metadata**

| Field | Type | What it tells you |
|---|---|---|
| `language` | string | Two-letter language code of the feed edition, e.g. `en`. |
| `country` | string | Two-letter country code of the feed edition, e.g. `US`. |
| `feedTitle` | string | Title of the feed the row came from, e.g. `"apify" - Google News`. |
| `feedUrl` | string | URL of the feed the row came from, so you can tell rows apart when one run scrapes several feeds. |
| `position` | integer | 1-based position of the article inside its feed, in Google's own order. |
| `url` | string | The article's Google News link; present on every row, including `error` rows. |
| `status` | string | `ok`, `not_found` or `error` (see below). |
| `error` | string | Reason when `status` is not `ok`. |
| `scrapedAt` | string | ISO 8601 time of extraction. |

A missing optional field is honest: it means Google News did not publish that value in the feed, never a guess.

#### Result status (tri-state output)

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | The article was found and extracted. | Yes |
| `not_found` | Google News answered with a valid feed that contains no articles (a search nothing matches, or a topic with no current items). | No |
| `error` | The feed could not be read after retries (network error, HTTP error, or an unexpected response). `error` says why. | No |

### Output

Export the dataset as JSON, CSV, Excel, XML or HTML, or read it from the API. This is a real row from the default run (2026-09-08), followed by a free `not_found` row:

```json
[
    {
        "url": "https://news.google.com/rss/articles/CBMigAFBVV95cUxPZkh6d3hkX2RaWUpjSGtmeEJjS0NLTXNzWkk4eF9CQWJxYTRFVGFhY2VlLVJIRFRaeE5nWnlVZ0trVy1NNVpENkRZUWxVRUoxRkFMR2FaLWZMeV9aVTlYZGtqaVJZcjBjd2xZNjV5dG12dERmWnhDS3E1dldhNm9IdA?oc=5",
        "status": "ok",
        "scrapedAt": "2026-09-08T11:42:49.977Z",
        "title": "Early Data Indicates an A.I.-Generated Drug Could Slow Aging - The New York Times",
        "link": "https://news.google.com/rss/articles/CBMigAFBVV95cUxPZkh6d3hkX2RaWUpjSGtmeEJjS0NLTXNzWkk4eF9CQWJxYTRFVGFhY2VlLVJIRFRaeE5nWnlVZ0trVy1NNVpENkRZUWxVRUoxRkFMR2FaLWZMeV9aVTlYZGtqaVJZcjBjd2xZNjV5dG12dERmWnhDS3E1dldhNm9IdA?oc=5",
        "source": "The New York Times",
        "sourceUrl": "https://www.nytimes.com",
        "publishedAt": "2026-09-07T09:04:03.000Z",
        "snippet": "Early Data Indicates an A.I.-Generated Drug Could Slow Aging The New York Times",
        "guid": "CBMigAFBVV95cUxPZkh6d3hkX2RaWUpjSGtmeEJjS0NLTXNzWkk4eF9CQWJxYTRFVGFhY2VlLVJIRFRaeE5nWnlVZ0trVy1NNVpENkRZUWxVRUoxRkFMR2FaLWZMeV9aVTlYZGtqaVJZcjBjd2xZNjV5dG12dERmWnhDS3E1dldhNm9IdA",
        "language": "en",
        "country": "US",
        "feedTitle": "\"artificial intelligence\" - Google News",
        "feedUrl": "https://news.google.com/rss/search?q=artificial%20intelligence&hl=en-US&gl=US&ceid=US:en",
        "position": 1
    },
    {
        "url": "https://news.google.com/rss/search?q=zzqx9v7wkjmqp4rtl2bnvx8yq&hl=en-US&gl=US&ceid=US:en",
        "status": "not_found",
        "error": "No results on this page",
        "scrapedAt": "2026-09-08T11:42:50.104Z"
    }
]
```

The **Articles** dataset view shows `title`, `source`, `publishedAt`, `link`, `snippet`, `status`, `error` and `scrapedAt`; the **All fields** view shows every column.

### How to scrape Google News headlines by keyword, topic or publication

1. Open the Actor in Apify Console and click **Try for free**.
2. Choose what to scrape: paste a Google News URL into **Google News URLs or RSS feeds**, type a **Search query**, or pick a **Topic section**. Precedence is URLs, then query, then topic.
3. Optionally set **Language** and **Country edition** (defaults `en` / `US`) and **Maximum results** (default 20).
4. Click **Start**. The default input takes a few seconds and rows appear in the dataset in real time.
5. Open the **Output** tab or **Export** the dataset as JSON, CSV, Excel, XML or HTML.

To automate it, use the **API** tab (Node.js, Python, curl examples) or add a **Schedule** and run it hourly.

### Input

Every field, its default and when you would change it:

| Field | Type | Default | When to change it |
|---|---|---|---|
| `startUrls` | array of strings | one sample search feed | Use it when you already have a Google News search, topic, publication or `/rss/` URL — browser URLs are rewritten to the matching feed automatically. Pass several to cover several beats in one run. |
| `query` | string | – | The simplest way to start: type a keyword or phrase instead of a URL. Google News operators such as `when:7d`, `site:reuters.com` or `intitle:` work here. Used only when `startUrls` is empty. |
| `topic` | string | – | Pick a headline section (`WORLD`, `NATION`, `BUSINESS`, `TECHNOLOGY`, `ENTERTAINMENT`, `SPORTS`, `SCIENCE`, `HEALTH`) when you want general coverage rather than a search. Used only when `startUrls` and `query` are both empty. |
| `language` | string | `en` | Change it to scrape a non-English edition (`de`, `es`, `fr`, `pt`, `ja`, ...). Applies to `query` and `topic`; a pasted Start URL keeps its own edition. |
| `country` | string | `US` | Change it to scrape another country edition (`GB`, `DE`, `IN`, `BR`, ...), or run the same query across several countries to compare coverage. |
| `maxItems` | integer | `20` | Raise it for production runs. One feed holds roughly 100 articles, so go above 100 only when you pass several feeds. It is also your hard cap on spend. |
| `resolvePublisherUrl` | boolean | `false` | Turn it on when you want the publisher's own URL where it can be decoded locally. It costs no extra request, but it only works for Google's older link format (see Limitations). |
| `proxyConfiguration` | object | Apify Proxy off | Leave it off. Enable Apify Proxy (datacenter group) only if a run starts producing `error` rows; residential proxies are not needed. |

Example input (this is the whole thing):

```json
{
    "startUrls": ["https://news.google.com/rss/search?q=artificial%20intelligence&hl=en-US&gl=US&ceid=US:en"],
    "language": "en",
    "country": "US",
    "maxItems": 20,
    "resolvePublisherUrl": false
}
```

Search a keyword instead of a URL:

```json
{ "query": "electric vehicles when:7d", "language": "en", "country": "GB", "maxItems": 50 }
```

Scrape a topic section:

```json
{ "topic": "TECHNOLOGY", "language": "de", "country": "DE", "maxItems": 100 }
```

### How much does it cost to scrape Google News?

This Actor uses **pay-per-event** pricing. The table below is the whole price list:

| Event | Charged when | Price |
|---|---|---|
| Actor start | Once per run, by the Apify platform (one event per GB of memory; the default is 1 GB). | $0.005 per run |
| Article | One article with `status: ok` is saved to the dataset. | $0.00149 per article |

- 1,000 articles cost about **$1.50** ($0.005 start + 1,000 × $0.00149).
- Rows with `status` `not_found` or `error` are **never charged** — a query that matches nothing costs you the start fee only.
- The Actor stops gracefully when your run's maximum charge is reached. Cap spending with **Maximum results** and with the run's **Max total charge** option.
- The free Apify plan's $5 of monthly credit covers about 3,350 articles in a single run.

### Speed and request budget

Measured on the default input (one search feed, `maxItems: 20`), 1 GB memory, no proxy, across three consecutive staging runs:

| Metric | Value |
|---|---|
| HTTP requests | 1 |
| Articles parsed from that request | 100 |
| Rows saved (`maxItems` cap) | 20 |
| Run duration | 2.3 – 3.8 s |

One request covers a whole feed, so the request budget is roughly **0.01 requests per article** — the reason this Actor is priced below the category median.

### How it compares

This Actor is the cheap, fast, headline-level option. Its strengths are breadth and cost: one request per feed, up to ~100 articles from it, a stable `guid` for deduplication, every language and country edition Google News publishes, and a tri-state `status` so a scheduled job can tell "nothing matched" apart from "the fetch failed".

It is not for you if you need **full article text**, paywalled content, historical archives going back years, or per-article sentiment and entity extraction — none of that is in the feed, and this Actor deliberately does not fetch publisher pages to get it. It is also not a general web crawler: the input is a Google News query, topic or URL, not an arbitrary site. Pair it with a separate article-extraction Actor if you need bodies, and use the `link` column as the hand-off.

### Integrations, API and AI agents

Results export to **CSV, JSON, Excel**, XML and HTML, and can be pushed to **Google Sheets, Airtable, Slack or a CRM** through Apify integrations and webhooks (n8n, Make and Zapier included). Add a **Schedule** to run it hourly and deduplicate downstream on `guid`.

The Actor can be called from the **Apify API** (Node.js, Python or curl — see the **API** tab), from the **Apify MCP server**, or from any AI agent: inputs are plain strings and every row is self-describing thanks to `status` and `error`, so an agent never has to guess why a run returned nothing.

### FAQ

**Do I get the full article text?** No, and that is deliberate. Article bodies are copyrighted by the publishers. You get the headline, snippet, publisher, timestamp and link; follow the `link` yourself if you need more, under the publisher's own terms.

**Is it legal to scrape Google News?** Reading a publicly available RSS feed is generally lawful, but you are responsible for how you use the output. Google's feed terms restrict redistribution of the feed itself, and headlines and snippets remain the publishers' content. Read the legal notice below, and consult your lawyers if you are unsure.

**Why is `link` a news.google.com URL and not the publisher's URL?** Google publishes redirect links in its feeds and encrypts the destination inside the article token. The link opens the article in any browser. See Limitations for what `resolvePublisherUrl` can and cannot do.

**How do I get more than 100 articles on a topic?** Run several narrower queries (by keyword, by `site:`, or by a `when:`/`after:`/`before:` time window), or scrape several country editions, and pass them as multiple Start URLs in one run — you pay the start fee once.

**Can I use this Actor from an AI agent or MCP client?** Yes. Every row is self-describing (`status` plus `error`), inputs are plain strings, and results can be fetched via the dataset API or the Apify MCP server.

**Which languages and countries work?** Any edition Google News publishes. Set `language` to a two-letter code (`en`, `de`, `es`, `fr`, `pt`, `ja`, ...) and `country` to a two-letter code (`US`, `GB`, `DE`, `IN`, `BR`, ...). A pasted Start URL keeps the edition it already carries.

**Why did I get fewer rows than `maxItems`?** The feed contained fewer articles, or the run hit your **Max total charge** limit. Check the run log for "Stopping gracefully".

**How do I run brand monitoring on a schedule?** Add a Schedule in Apify Console with your brand names as the query, keep `maxItems` at what one feed returns, deduplicate on `guid`, and send new rows to Slack or a sheet with a webhook.

### Limitations

- **No full article text.** By design the Actor stores only what the feed publishes: headline, snippet, link and metadata. Article bodies are the publishers' copyrighted content and are never fetched or stored.
- **Google News caps each feed at roughly 100 articles**, and there is no pagination. To get more, split the work: several narrower queries, several topic sections, several country editions, or a `when:` operator per time window. Setting `maxItems` above ~100 with one feed will simply return what the feed contains.
- **Links are Google News redirect URLs.** Google encrypts the destination inside the article token, so the publisher URL is not present in the feed. `resolvePublisherUrl` decodes it locally for Google's older link format only; for the format Google issues today it stays empty and `link` remains the Google News URL, which still resolves to the article in a browser. This Actor deliberately does not spend an extra request per article trying to unwrap the redirect.
- **`imageUrl` is usually empty** for search and topic feeds, because Google does not include media items in them.
- **`snippet` often repeats the headline and publisher** in search and topic feeds; on "full coverage" items it lists the related headlines instead. That is what Google puts in the feed's description.
- **No historical archive.** A feed returns what Google News currently ranks for that query or topic. For older coverage use search operators such as `after:2026-01-01 before:2026-02-01` in the query.
- Google News may change its feed format, in which case rows come back as `error` and the Actor is updated quickly (report it in the **Issues** tab).

### Troubleshooting

| Symptom | Fix |
|---|---|
| One `not_found` row and nothing else | The query matched no articles. Broaden it, drop a `when:` operator, or check the language/country edition. |
| Fewer rows than `maxItems` | The feed contained fewer articles (see the ~100 cap), or the run hit your **Max total charge**. Look for "Stopping gracefully" in the log. |
| `error` rows mentioning HTTP failures | Rare from Apify's datacenter IPs. Re-run, or enable Apify Proxy (datacenter group) in **Proxy configuration**. |
| Duplicate articles across scheduled runs | Deduplicate on `guid`, which is stable for a given article. |
| A pasted browser URL returns nothing | Make sure it is a Google News URL (`news.google.com`). The Actor rewrites `/search`, `/topics/...` and `/publications/...` to their feeds automatically. |

### Privacy and responsible use

- Only publicly available Google News feed data is read; no login, no account, no access controls are circumvented.
- Only headline, snippet, link and metadata are stored. Article bodies are never fetched or stored.
- Journalist and author names may appear incidentally inside a headline or snippet, exactly as Google News publishes them. No contact details, no e-mail addresses and no phone numbers are collected or added.
- Publisher and headline data is business information, not personal profiling data; use it for lawful purposes such as monitoring, research and analytics.
- You are responsible for how you use, store and republish the output.

### Legal and data-protection notice

This Actor reads only data that Google News publishes publicly in its RSS feeds; it does not extract private user data such as e-mail addresses, phone numbers, gender or precise location, it does not log in, and it does not circumvent access controls. It stores no article body text. However, your results could still contain personal data, for example a journalist's name inside a headline. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. You are responsible for complying with Google's terms of service, with the publishers' terms, and with applicable law when using the extracted data.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google LLC or any publisher whose articles appear in the output. All trademarks belong to their respective owners.

# Actor input Schema

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

One URL per line. Accepts Google News search URLs (news.google.com/search?q=...), topic URLs (news.google.com/topics/...), publication URLs (news.google.com/publications/...) and the matching RSS feed URLs (news.google.com/rss/...). Non-RSS Google News URLs are read as their RSS equivalent. Leave empty to use Search query or Topic instead.

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

Keyword or phrase to search Google News for, e.g. `electric vehicles` or `"open source" AI`. Google News search operators work here too, for example `when:7d`, `site:reuters.com` or `intitle:apify`. Used only when Start URLs is empty.

## `topic` (type: `string`):

Scrape one of Google News' topic headline feeds instead of a search. Used only when both Start URLs and Search query are empty.

## `language` (type: `string`):

Two-letter language code for the Google News edition (the `hl` and `ceid` parameters), e.g. `en`, `de`, `es`, `fr`. Applies to Search query and Topic; a Start URL keeps whatever edition it already contains.

## `country` (type: `string`):

Two-letter country code for the Google News edition (the `gl` and `ceid` parameters), e.g. `US`, `GB`, `DE`, `IN`. Applies to Search query and Topic; a Start URL keeps whatever edition it already contains.

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

Stop after this many records have been saved to the dataset. Each saved record with status `ok` is one billable result. One Google News feed returns roughly 40-100 articles, so raise this only when you pass several feeds.

## `resolvePublisherUrl` (type: `boolean`):

Add a `publisherUrl` column with the article's URL on the publisher's own site, decoded from the Google News link. Decoding happens locally and costs no extra request, but it only succeeds for Google's older link format; for links Google encrypts server-side the column stays empty and `link` keeps the Google News URL. Following such a link to the publisher would cost one extra request per article, which this Actor deliberately does not do.

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

Optional. The Actor is HTTP-only and Google News RSS answers datacenter IPs directly, so no proxy is needed. Enable Apify Proxy (datacenter group) only if you see `error` rows; residential proxies are not needed for this Actor.

## Actor input object example

```json
{
  "startUrls": [
    "https://news.google.com/rss/search?q=artificial%20intelligence&hl=en-US&gl=US&ceid=US:en"
  ],
  "language": "en",
  "country": "US",
  "maxItems": 20,
  "resolvePublisherUrl": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        "https://news.google.com/rss/search?q=artificial%20intelligence&hl=en-US&gl=US&ceid=US:en"
    ],
    "language": "en",
    "country": "US",
    "maxItems": 20,
    "resolvePublisherUrl": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/news-headlines-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 = {
    "startUrls": ["https://news.google.com/rss/search?q=artificial%20intelligence&hl=en-US&gl=US&ceid=US:en"],
    "language": "en",
    "country": "US",
    "maxItems": 20,
    "resolvePublisherUrl": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/news-headlines-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 '{
  "startUrls": [
    "https://news.google.com/rss/search?q=artificial%20intelligence&hl=en-US&gl=US&ceid=US:en"
  ],
  "language": "en",
  "country": "US",
  "maxItems": 20,
  "resolvePublisherUrl": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/news-headlines-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glasswing/news-headlines-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/1gBvJTAbQ8JiQqd6R/builds/VhSOJfNPB3dzt2Fn0/openapi.json