# Google News Scraper (`automatic/google-news-scraper`) Actor

Collect Google News headlines by search, topic, edition or location. Return publisher, publication time, story clusters and matched searches, with optional publisher links, article text and scheduled new-only delivery.

- **URL**: https://apify.com/automatic/google-news-scraper.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** News
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 articles

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?

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

## Google News Scraper

Collect Google News headlines for sports coverage, company monitoring, research and news alerts. Search with Google's news operators, choose a topic or location, and select a language/country edition. Each article includes its publisher, publication time, Google News link and the searches it matched. Publisher article links and readable article text are optional.

### Use cases

- Build a sports news writing queue from team, league or player searches.
- Send trading research systems timestamped company and market headlines. Verify a story before acting on it.
- Monitor competitors and selected publishers with domain filters.
- Schedule a new-article feed for daily newsletters and news alerts.

### Also available

The Google data suite: pick the job.

| Actor | Use when |
|---|---|
| **Google News (this Actor)** | Headlines by topic, search or edition |
| [Google Search Results](https://apify.com/automatic/google-search-results-scraper) | Rankings, snippets and AI Overviews per query |
| [Google Trends](https://apify.com/automatic/google-trends-scraper) | Search interest over time and by region |
| [Wikipedia Pageview Spikes](https://apify.com/automatic/wikipedia-pageview-spikes) | Articles whose daily views spiked |
| [Reddit](https://apify.com/automatic/reddit-scraper) | Posts and comments from subreddits and searches |

### Quick start

Run the Console prefill for 10 US English top headlines:

```json
{
  "topHeadlines": true,
  "language": "en-US",
  "country": "US",
  "maxItemsPerQuery": 10,
  "maxResults": 10,
  "resolvePublisherUrls": false,
  "fetchArticleText": false,
  "onlyNewSinceLastRun": false,
  "deduplicate": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

A bare input `{}` also delivers a sample of up to 10 current top headlines. Its status begins **Sample run (...)** and `OUTPUT.sampleRun` is `true`. Language, country and other option settings alone still use this sample; select a source or set a result cap to start an explicit run. An explicit cap without sources selects top headlines and honors that cap. An explicit empty list, an empty string or a null field ends the run with no rows and names the field to fix. A single entry a source cannot use (a blank query, an unknown topic, a malformed domain) is skipped and listed in `OUTPUT.skippedSearches` while the rest still run; a source list where every entry is unusable ends the run with no rows and says so.

For two small searches from the last day, run:

```json
{
  "queries": [
    "football",
    "basketball"
  ],
  "publishedWithin": "1d",
  "maxItemsPerQuery": 3,
  "maxResults": 6
}
```

These examples were run locally on November 11, 2026. Search results change over time.

### Inputs

All inputs are optional. Supply one or more of `queries`, `topics`, `topHeadlines: true` or `locations` to select sources. Sources combine in one run. Unknown fields and incorrect types fail before collection.

| Field | Omitted behavior | Description |
| --- | --- | --- |
| `queries` | No searches | 1–20 nonempty strings, each up to 500 characters. Quotes, `OR`, `-term`, `site:`, `intitle:`, `when:`, `after:` and `before:` pass through. |
| `topics` | No topics | 1–20 choices from WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH. |
| `topHeadlines` | False; true for sample | Include current top headlines for the selected edition. |
| `locations` | No locations | 1–20 place names, each up to 500 characters. Google decides geographic coverage. |
| `language` | `en-US` | Exact supported edition language code; see the edition table. |
| `country` | `US` | Exact uppercase supported edition country code. |
| `publishedWithin` | No recent-window filter | `1h`–`99h` or `1d`–`31d`, for example `6h`. Filters by publication time in UTC. |
| `dateFrom` | No date range | Inclusive UTC date `YYYY-MM-DD`; requires `dateTo` and search queries only. |
| `dateTo` | No date range | Inclusive UTC date `YYYY-MM-DD`; requires `dateFrom`. At most 31 inclusive days. |
| `sites` | All publishers | 1–20 lowercase domains, without schemes or paths. Includes their subdomains. |
| `excludeSites` | No exclusions | 1–20 lowercase domains to exclude, including subdomains. Cannot overlap `sites`. |
| `maxItemsPerQuery` | 100; 10 for sample | 1–1,000 articles considered per original source across all date slices, before cross-source deduplication and saved-state filtering. |
| `maxResults` | 100; 10 for sample | 1–5,000 total delivered rows. Sample is always capped at 10. |
| `resolvePublisherUrls` | False | Recover publisher article links where possible; failures keep the Google News link and include a reason. |
| `fetchArticleText` | False | Fetch readable publisher text and metadata. Automatically enables URL resolution. |
| `onlyNewSinceLastRun` | False | Deliver only article IDs not previously delivered under the same state key. |
| `stateKey` | Derived from sources, edition and domain filters | Nonempty name of up to 64 characters for a scheduled feed. Use a new name for a fresh baseline. |
| `deduplicate` | True | Deliver an article once across sources. `matchedQueries` lists matching source labels known when that row was delivered. Matches found by later feeds are retained in `OUTPUT.additionalMatches`, keyed by article ID. |
| `proxyConfiguration` | Direct connection | Optional connection settings on Apify. Each custom proxy/group list permits 1–20 nonempty strings, up to 2,048 characters each. Local runs permit only the disabled setting shown in the prefill. |

Duplicate list entries are trimmed and collapsed in first-occurrence order. Non-Latin search text is supported; whitespace-only strings fail. Lists and result caps use Console prefill values rather than injected defaults. An explicit run without caps can return up to 100 rows; the prefill requests only 10.

#### Supported editions

Use one of these exact language/country pairs. Changing `country` does not automatically change `language`.

| Language | Countries |
| --- | --- |
| `en-US` | US |
| `en-GB` | GB |
| `en-CA` | CA |
| `en-AU` | AU |
| `en-IN` | IN |
| `es` | ES, PE |
| `es-419` | MX |
| `pt-BR` | BR |
| `fr` | FR |
| `de` | DE |
| `it` | IT |
| `ar` | SA, EG |
| `he` | IL |
| `ja` | JP |
| `ko` | KR |
| `zh-CN` | CN |
| `zh-TW` | TW |
| `hi` | IN |

All 20 listed language/country pairs were checked against live feeds on November 11, 2026. The edition affects Google's selection and language preference; it does not translate articles or guarantee every result uses that language.

#### Time windows and coverage

For searches, `publishedWithin` adds Google's `when:` operator and also filters returned publication timestamps locally. For topics, top headlines and locations it filters the current feed locally. It cannot recover articles that have already left that feed.

A `dateFrom`/`dateTo` search automatically splits into one request per UTC day. Each search uses broadened `after:`/`before:` boundaries, then keeps only that slice's exact UTC day. `OUTPUT.dateRangeSplitByDay` and `dateSlices` show the split. If you also set `publishedWithin`, both restrictions apply. Operators already inside a query remain in place and can further narrow the results.

Each Google News RSS feed returns **at most about 100 items**; 104 were observed in one live search. There is no next-page collection. Daily splitting helps with wide windows but a busy day can still omit articles. Split busy searches further by publisher or keyword. Historical dates are supported for searches only; dated topic, headline and location requests fail with a message naming the date fields. A run can plan at most 60 feeds. Combined queries/domain filters must fit an 8,000-character encoded source URL; oversized combinations fail before collection.

Domain filters add `site:` restrictions to searches and also check each returned publisher domain locally. For other feed types they filter the current feed locally. An article without a known publisher domain cannot pass an include-domain filter.

### Output example

One complete headline record captured from the two-search example above:

```json
{
  "articleId": "b1ca1abf17d836fdab8205cf44deabbdef8bc6611c472a8a01bebc265c1dbcc5",
  "title": "College Football Playoff bracket, based on current committee rankings",
  "publisher": "NCAA.com",
  "publisherUrl": "https://www.ncaa.com",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMiuwFBVV95cUxOQkhLcTVfbXYyZnRNeGo0MkNLeTE3WEhSVk81QmhfU2NaYWJkcTZxU2c1SGxHQ2JfbXphU2dHX01YNko1QmVodHg3SDIxTnhDcnRsX0dabmVEb2VZRUx6dFY0YUlhaGFKcE1TUTlpV2VtMnhSUjhzc3owN0stUjNyUThxTlZOOEFvMFdTUVhya3pIZEV4V2UwbXVNalVOaU9FMmY3YXZhMDFBYVIxUFFZUTBXTlhrVklfYWFB0gHAAUFVX3lxTE1ONHRBRHlUbUNZZ1BzMnpnUmUxMFd0UDVGYU1IYnNQcW9BRXRpTkVPQ2h1eTFqSzU2Q3hOZVNfTjZET2dGbGh3cFVaR1BvNnhXUXJnMlV1UFBGT2lUN25EekpGQlpsb0tSS05fYUN2TU1Vdm9QSnRrWG5IOWstZG9EODdYX0drSGtvVXdoWWNLUmZnNWRxZURhQnZKbEYwRk8yblc3UFlOZ2tFOTlmc0E1ejctTHY1RThiaFowX29pMw?oc=5",
  "resolvedUrl": null,
  "resolutionStatus": "not_requested",
  "resolutionReason": null,
  "publishedAt": "2026-11-11T21:45:51+00:00",
  "description": "College Football Playoff bracket, based on current committee rankings NCAA.com",
  "relatedArticles": [],
  "query": "football",
  "matchedQueries": [
    "football"
  ],
  "feedType": "search",
  "topic": null,
  "language": "en-US",
  "country": "US",
  "collectedAt": "2026-11-11T22:08:56.962111+00:00",
  "article": null
}
```

The default dataset contains **one row per delivered article**. Cross-source duplicates share one row when `deduplicate` is true; the first match supplies `query`, `feedType` and `topic`. With deduplication off, an article can have multiple rows, each retaining every matched source label. New-only mode always delivers each ID once per run.

| Field | Meaning |
| --- | --- |
| `articleId` | Stable SHA-256 of Google's item ID, or its link ID when no item ID is supplied. Different Google IDs for the same publisher story remain different articles. |
| `title`, `publisher`, `publisherUrl` | Article headline, publisher name and publisher home page, as provided by Google. Publisher fields may be null. |
| `googleNewsUrl` | Original Google News article link, always retained. |
| `resolvedUrl` | Recovered publisher article URL; null when not requested or unavailable. |
| `resolutionStatus`, `resolutionReason` | Status: `not_requested`, `offline`, `redirect`, `lookup` or `failed`; failure reason when applicable. |
| `publishedAt` | Google's item publication timestamp, ISO 8601 in UTC. Items with unusable publication times are counted and skipped. |
| `description` | Google's description with HTML removed. Often a headline or a list of related headlines, rather than a prose summary. |
| `relatedArticles` | Other linked stories in Google's item description, each with `title`, `publisher` and `link`. Not separately delivered or fetched. |
| `query`, `matchedQueries` | First matching source label and all matching labels observed in the fetched feeds. Non-search labels are the topic, location or “Top headlines”. |
| `feedType`, `topic` | `search`, `topic`, `topHeadlines` or `location`; topic code only for a topic row. |
| `language`, `country` | Requested edition. |
| `collectedAt` | Collection timestamp, ISO 8601 UTC. |
| `article` | Null unless text was requested. Includes `title`, `text`, `author`, `publishedAt`, `image`, `canonicalUrl`, `wordCount` and `fetchStatus`. |

Article extraction uses readable content available on the publisher page. Metadata can be null; publisher publication times without a timezone are left null. `wordCount` counts whitespace-separated tokens and can undercount CJK text. A successful extraction does not certify that a publisher exposed its entire article. Restricted subscriptions, access refusals, non-HTML responses, short or missing article content, oversized pages and timeouts have distinct failure statuses and null text. The headline row is still delivered. Text collection has a 2 MB response limit, a 20-second HTTP timeout and a per-domain delay. A mixed-publisher check on November 11 extracted text from only 3 of 6 pages; the other pages reported a paywall or missing text. Success varies substantially by publisher and network, so do not assume that most pages will yield text. URL and text enrichment process at most six articles concurrently, with request pacing and shared backoff after rate limits.

The **OUTPUT** key-value record is an uncharged run summary: delivered and attempted rows, per-source/date counts, HTTP request and response-byte counts, failure reasons, enrichment successes, sample flag, cap indicators, saved-state information and `summaryLine`. Source-feed cap indicators are approximate. Per-feed delivered counts include shared matches and can sum above dataset rows. A terminal status repeats the summary. If every feed fails, the run fails with the reasons; partial failures remain visible alongside delivered rows. `OUTPUT.status` is `succeeded`, `succeeded_partial` (some inputs were skipped), `no_results` (the feeds were read but matched no articles) or `failed`.

### Scheduling and new-only feeds

Schedule the same input on Apify and enable `onlyNewSinceLastRun`. This live-tested small baseline is suitable for trying the behavior:

```json
{
  "queries": [
    "site:theguardian.com football"
  ],
  "maxItemsPerQuery": 3,
  "maxResults": 3,
  "onlyNewSinceLastRun": true,
  "stateKey": "live-gnews-feed"
}
```

The first run delivers its baseline. The second identical local run delivered zero and charged no article events. Adding a second search under the same state key delivered three previously unseen IDs. Timing and changes in Google selection can change these counts.

The named store remembers **up to 20,000 IDs for 90 days after delivery**, independently of a run's default storage. Expired or evicted IDs can be delivered again. OUTPUT reports `feed.expiredIds` and `feed.evictedIds`; an eviction also warns in the terminal status. The most recently delivered IDs win retention ties. Only stored rows enter the ledger, including when a spending limit stops a batch. Reading corrupt state fails rather than silently resetting it. A state-save failure is reported and may cause repeat deliveries next time. A concurrent run with the same state key fails before source collection with a `stateKey` busy message. Different state keys can run concurrently. After an interrupted run, its exclusive lease can take up to 15 minutes to expire. The lock prevents overlapping writers; it cannot make dataset delivery and state persistence one atomic transaction. A forced termination or state-save failure between them can cause repeat deliveries, so consumers should also deduplicate by `articleId`. Older or unsupported state shapes fail with a field-named message; use a new state key rather than silently resetting history.

The per-source article cap applies before saved-state filtering. Set it high enough to cover each current feed. If total eligible articles exceed `maxResults`, the next run can deliver additional previously undelivered IDs from the same source window. The ledger tracks IDs, not headline edits. Use a new `stateKey` when you want to resend a baseline. Export or process dataset rows through the usual Apify dataset integrations; OUTPUT is a summary, not a dataset row.

### Pricing

**$0.0025 per article ($2.50 per 1,000) plus $0.005 per run start; resolving publisher URLs and fetching article text are included at no extra charge**

Under pay per event there is no separate compute or proxy charge. The start fee applies even when no articles are delivered. Apify counts starts per GB of memory; the default 512 MB run is one start event. Memory is capped at 1,024 MB to keep that count at one.

A 10-article sample costs $0.030 ($0.025 in article events + $0.005 start). A 100-article run costs $0.255; 1,000 delivered articles in one run cost $2.505. A zero-new scheduled check costs $0.005. Splitting the same articles across multiple runs adds a start fee each time.

One dataset item is delivered per article. Cross-source duplicates are suppressed when `deduplicate` is true, and new-only mode suppresses previously delivered IDs. The delivered prefix stops at the run's spending allowance and the status states “allowed N of M”. A spending allowance of $0.010 permits the start and two articles; no uncharged article rows are written.

### Limits and freshness

Google News RSS is a changing selection of indexed publisher stories, not a complete news archive. Some publishers and articles are absent, clusters change, and publication times can differ from a publisher's page. Google controls freshness and search semantics; there is no real-time delivery guarantee. A zero-result explicit search is valid. Check the summary and publication timestamps before using headlines in time-sensitive systems.

Rows are saved after each feed, before waiting for later sources. Later feeds can add provenance through `OUTPUT.additionalMatches`; earlier dataset rows are not rewritten. Planned feeds are still inspected for matches after the result cap, unless a charge, time or storage limit stops the run. Optional text and link work runs only for selected new rows. A run keeps at most an eight-minute collection/enrichment budget and reserves 45 seconds before the platform deadline for delivery and a summary. If enrichment runs out of time, collected metadata is still delivered and unfinished enrichment reports `time_budget`. OUTPUT is checkpointed during collection. A hard stop or abort can still interrupt the final in-flight write. Use at least a 600-second timeout for larger runs and smaller result limits when enrichment is enabled. Daily schedules can miss stories that enter and leave the current feeds between runs.

### FAQ

**Can I collect more than 100 articles?** Combine sources or use an explicit date range, which splits searches by day. Increase both relevant result caps. A single feed still contains only about 100 selected items and cannot be paged.

**Does the description contain the article?** Usually it contains a headline or related-story list. Enable `fetchArticleText` for optional publisher text and inspect `article.fetchStatus`.

**Will every publisher URL resolve?** No. Failed resolution leaves `resolvedUrl: null`, keeps `googleNewsUrl`, and records `resolutionReason`. No publisher is substituted.

**Does a schedule resend yesterday's news?** Enable new-only mode and keep the same state key. It suppresses delivered IDs while they remain in the ledger; new Google IDs and expired state can appear again.

**Can I export JSON or CSV?** Yes. Use the Apify dataset export options; JSON retains nested related-story and article fields most naturally.

# Actor input Schema

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

Search strings; quotes, OR, -term, site:, intitle:, when:, after: and before: pass through. Max 20.

## `topics` (type: `array`):

Choose WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE or HEALTH. Max 20.

## `locations` (type: `array`):

Place names for current local news, such as London. Max 20.

## `topHeadlines` (type: `boolean`):

Include current top headlines for the selected edition. A bare start samples 10 headlines.

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

Exact language code from a supported language/country pair; see README. Omitted: en-US.

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

Exact uppercase country code from a supported language/country pair; see README. Omitted: US.

## `publishedWithin` (type: `string`):

Recent window, 1h..99h or 1d..31d, such as 6h. Search operator plus local UTC filtering; other feeds are filtered locally.

## `dateFrom` (type: `string`):

Inclusive UTC date YYYY-MM-DD. Supply both dates; queries only, at most 31 days. Search is split by day.

## `dateTo` (type: `string`):

Inclusive UTC date YYYY-MM-DD. Supply both dates; queries only, at most 31 days. Search is split by day.

## `sites` (type: `array`):

Only articles from these lowercase domains or their subdomains, without schemes or paths. Max 20.

## `excludeSites` (type: `array`):

Exclude these lowercase domains and their subdomains. Max 20.

## `maxItemsPerQuery` (type: `integer`):

Cap per original search, topic, headline or location source, across date slices. Omitted: 100, or 10 for sample.

## `maxResults` (type: `integer`):

Maximum dataset rows. Omitted: 100, or 10 for sample. Bare-start sample always capped at 10.

## `resolvePublisherUrls` (type: `boolean`):

Try to recover the original article URL. Failures retain the Google link and a reason. Omitted: false.

## `fetchArticleText` (type: `boolean`):

Fetch resolved publisher HTML for article text and metadata. Enables URL resolution. Omitted: false.

## `onlyNewSinceLastRun` (type: `boolean`):

Remember delivered IDs in a named store. Repeated runs with the same state key skip them. Omitted: false.

## `stateKey` (type: `string`):

Name up to 64 characters. Omitted: derived from source and edition filters. Retains 20,000 IDs for 90 days from delivery.

## `deduplicate` (type: `boolean`):

Deliver an article once with every observed matched source in matchedQueries. Omitted: true.

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

Optional explicit connection configuration on Apify. Omit for direct connections. Local runs allow only useApifyProxy=false.

## Actor input object example

```json
{
  "topHeadlines": true,
  "language": "en-US",
  "country": "US",
  "maxItemsPerQuery": 10,
  "maxResults": 10,
  "resolvePublisherUrls": false,
  "fetchArticleText": false,
  "onlyNewSinceLastRun": false,
  "deduplicate": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "topHeadlines": true,
    "language": "en-US",
    "country": "US",
    "maxItemsPerQuery": 10,
    "maxResults": 10,
    "resolvePublisherUrls": false,
    "fetchArticleText": false,
    "onlyNewSinceLastRun": false,
    "deduplicate": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/google-news-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 = {
    "topHeadlines": True,
    "language": "en-US",
    "country": "US",
    "maxItemsPerQuery": 10,
    "maxResults": 10,
    "resolvePublisherUrls": False,
    "fetchArticleText": False,
    "onlyNewSinceLastRun": False,
    "deduplicate": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/google-news-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 '{
  "topHeadlines": true,
  "language": "en-US",
  "country": "US",
  "maxItemsPerQuery": 10,
  "maxResults": 10,
  "resolvePublisherUrls": false,
  "fetchArticleText": false,
  "onlyNewSinceLastRun": false,
  "deduplicate": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automatic/google-news-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatic/google-news-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/G1C3qvPCxEMIJkaLk/builds/MvXMWe3sHrewBGbDW/openapi.json
