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

Scrape Google News articles from keyword searches, sections and topic URLs. Returns title, publisher, publication time, edition, position, Google News link and, for keyword searches, the resolved publisher URL. Supports date ranges and several editions. No login needed.

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

## Pricing

from $1.48 / 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.
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?

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

**Returns:** one row per news article with title, url, source, publishedAt, googleNewsUrl, query, edition.
**Input:** `{"queries": ["nvidia earnings"], "editions": ["en-US"], "resolveUrls": true, "maxItems": 20}`
**Best for:** media monitoring, news sentiment datasets, competitor and brand mention tracking.

```json
{
  "title": "À Val-de-Cognac, Garandeau transforme ses anciennes carrières en géant du solaire",
  "source": "Charente Libre",
  "publishedAt": "2026-10-12T18:28:56.000Z",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMi3gFBVV95cUxPYWZiX19IZnZISHpwYkxfOTJuUTcxYl9NckgxVzZMZEdDbUI4M1hUb3JWTkkzZGMza3BVbUlQZVRRbi1NbHREMy1RcGNpLUVhWlRLUW83QkV2OC1PeDRJdkdoVlhsNnBLRWU2TV8yOTJNYlRTWDhHRkc0eWxodEJJRjdDTlB0aHRRMl84bUI0WHI1OEp4Y2JwdGl5S290SHZMLWJvZWR1Q2IwTnk1RlVhQ3NUcUY2ekFrdG9rb0tkb19SdzBtRmZBNDR6Z09VQzdQN2k3TFB0YnBDUXFJYXc?oc=5",
  "query": "énergie solaire",
  "edition": "FR:fr"
}
```

### What does Google News Scraper do?

Google News Scraper collects public article metadata from Google News keyword search feeds, news sections, and topic pages. It returns headlines, publisher names, publication times, Google News identifiers and links, and publisher article URLs when they are available. You can run one query, several queries, a named section such as TECHNOLOGY, or a Google News topic URL. The Actor works without a Google account or login.

The Actor uses Google News RSS feeds for keyword searches and the structured data in topic pages for sections and topics. Search feed links point to Google News article pages. With `resolveUrls` enabled, the Actor asks Google News for the publisher destination and stores it in `url`. Topic pages already include publisher destinations. The Actor does not fetch publisher websites or article bodies. Its output is suitable for headline monitoring, research queues, source comparison, and data pipelines that need links and dates.

Searches can include Google News operators such as quoted phrases, `OR`, `site:`, `intitle:`, `after:`, `before:`, and `when:`. You can also set a recent time range or explicit dates. Date ranges are split into daily search windows because one RSS search response has a limited number of items. Google News controls the order and coverage of results, so a date range does not guarantee every article published in that period.

### What data can you get?

Each dataset row represents one Google News article. All rows contain a stable `id` and `sourceUrl`, the Google News feed or topic page used for that row. Optional fields use `null` or an empty array when the source does not provide a value. The Actor removes repeated Google News IDs across feeds and windows.

| Field | Meaning |
| --- | --- |
| `id` | Stable identifier for this Google News article. |
| `title` | Headline, without the repeated publisher suffix used in some RSS titles. |
| `url` | Publisher article URL, if present on a topic page or resolved for a search result. |
| `source` | Publisher name shown by Google News, sometimes a bare domain such as `investopedia.com`. |
| `sourceUrl` | Google News RSS feed or topic page this row was read from. It is not the article; use `url`, or `googleNewsUrl` when `url` is null. |
| `publishedAt` | Publication time in ISO 8601 UTC when available. Date-only values appear as midnight US Pacific. |
| `publishedAtPrecision` | `date` when the source gave only a date, `datetime` when it gave a real time. |
| `googleNewsId` | Google News identifier used for deduplication. |
| `sourceWebsite` | Publisher home page from the feed's source element, or the origin of the article URL for topic rows. `null` when Google omits it. |
| `domain` | Hostname of the resolved publisher `url` without `www.`; `null` when `url` is `null`. |
| `googleNewsUrl` | Link to the article on Google News. |
| `imageUrl` | Image URL (topic and section rows only; null for keyword searches). |
| `authors` | Author names (topic rows only, when the page lists them; empty for keyword searches). |
| `storyId` | Story cluster identifier (topic rows only; null for keyword searches). |
| `relatedArticles` | Related articles when Google's RSS item lists a story cluster. Usually empty. |
| `query` | Search phrase that returned this article, or `null` in topic mode. |
| `topic` | Named section or topic identifier, or `null` in search mode. |
| `inputType` | `search` or `topic`. |
| `edition` | Country and language edition, such as `US:en`. |
| `position` | Item position within the source response. |
| `scrapedAt` | Time the Actor created the row. |

The overview table shows the most useful columns for scanning results. Download the full dataset as JSON, CSV, Excel, or another format available in Apify. Image and publisher URLs are returned as data; this Actor does not visit those hosts. A publisher URL may be missing if Google News does not provide a usable destination or changes its link format.

### How to use

1. Open the Actor input form and add at least one query, named section, or Google News topic URL.
2. Choose the editions you want to search. The default is `en-US`.
3. Set `maxItems` for the total number of records and `maxItemsPerQuery` for each search or topic in each edition.
4. Turn `resolveUrls` on when you need publisher article URLs from keyword searches. It is off by default, and resolved rows cost extra per result.
5. Run the Actor and open the Dataset tab to inspect or download the rows.

For a quick keyword test, use `nvidia earnings` with the prefilled values. To monitor a section, remove the query and add `TECHNOLOGY` or another section. To search an entity topic, supply its complete `https://news.google.com/topics/...` URL. You can combine these input types in one run. The total cap applies to the combined result set in input order, so put the most important source first when using a small cap.

The Actor checks input before making requests. Malformed date ranges, unknown editions, unsupported sections, and topic URLs outside Google News produce a clear error. Requests are paced at no more than two starts per second. Temporary Google News errors are retried with backoff. A consent page is not submitted or bypassed.

### Input

| Field | Type | Purpose |
| --- | --- | --- |
| `queries` | String array | Keyword searches and Google News operators. |
| `dateFrom`, `dateTo` | Date strings | Inclusive daily search window range, both required together. |
| `timeRange` | Choice | Recent period: `any`, `1h`, `1d`, `7d`, `30d`, or `1y`. |
| `topics` | String array | Uppercase named sections: TOP_STORIES, WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH. |
| `topicIds` | String array | Google News topic IDs beginning CAA; an alternative to full topic URLs. Default empty. |
| `publishedAfter` | ISO string | Keep publication timestamps strictly after an ISO date or timestamp. Default empty. |
| `topicUrls` | URL array | Google News topic pages for entities or other topics. |
| `editions` | String array | Editions as language-COUNTRY, for example `en-US` (list below). |
| `resolveUrls` | Boolean | Resolve search links to publisher URLs. Off by default; costs extra per result. |
| `maxItemsPerQuery` | Integer | Maximum items per query or topic and edition. |
| `maxItems` | Integer | Maximum items in the whole dataset. |
| `dedupeBy` | Choice | Deduplicate by `url`, `googleNewsId`, or `none`; IDs remain unique in all modes. |
| `proxyConfiguration` | Object | Apify Proxy settings for requests to Google News. |

Example input for a recent keyword search and a section:

```json
{
  "queries": ["climate change site:reuters.com"],
  "topics": ["SCIENCE"],
  "editions": ["en-US", "en-GB"],
  "timeRange": "7d",
  "resolveUrls": false,
  "maxItemsPerQuery": 50,
  "maxItems": 100
}
```

Supported editions are `en-US`, `en-GB`, `en-IN`, `en-AU`, `de-DE`, `fr-FR`, `es-ES`, `it-IT`, `pt-BR`, and `ja-JP`. Each edition is searched separately. The `edition` field in output uses Google News's country and language format, for example `GB:en`. If you set explicit dates, the Actor builds one search for each day and ignores `timeRange`. For large date ranges, the number of requests and run time increase with the number of days and editions. Google News may return fewer items than the cap, particularly for narrow searches.

`maxItems` is an exact upper bound: if at least that many distinct records exist in the selected sources, the dataset stops at that number. `maxItemsPerQuery` limits each input source in each edition before the total cap is reached. URL resolution adds one Google News article page request for each selected search result and groups up to ten resolution calls in one request. Topic rows already contain publisher URLs from their source page, so the setting does not change those URLs.

Use `publishedAfter` for scheduled monitoring: only strictly later publication timestamps are saved. Dates use midnight UTC; missing publication dates are excluded. Filtering happens before URL resolution. Repeated identical queries, sections, topic URLs and editions are fetched once. The Actor checks the remaining result budget before fetching another target and limits publisher URL resolution to rows that can still be charged. Retry responses are closed before the next attempt, freeing the HTTP connection. `topicIds` uses the same topic source as `topicUrls`. Neither option expands source coverage.

### Output

The following record is from a local TECHNOLOGY section run. The particular headline and link are live data, so later runs will return different articles.

```json
{
  "id": "CBMihgFBVV95cUxPRGYyaUdWZ2luQW5WZUZ4UkRyemNncUhiUHlNU2g0SjI3TDRENjdyNlczajY5QzVhVTNmalg1WTJMTHRmUTItRWpvaWVZeURZQVVvZ2MzcmZYVjJBZS1IMEtkVDRNZ3BaZUNNU0ltcFhqZFdiNWlvRmVDRUpmamdBaUdlYXo3Zw",
  "title": "Firefox just got a redesign with round tabs, new themes, and Compact Mode",
  "url": "https://www.theverge.com/tech/1001867/mozilla-firefox-157-redesign-compact-mode",
  "source": "theverge.com",
  "sourceUrl": "https://news.google.com/topics/CAAqKggKIiRDQkFTRlFvSUwyMHZNRGRqTVhZU0JXVnVMVlZUR2dKVlV5Z0FQAQ?hl=en-US&gl=US&ceid=US%3Aen",
  "publishedAt": "2026-09-29T13:00:00.000Z",
  "googleNewsId": "CBMihgFBVV95cUxPRGYyaUdWZ2luQW5WZUZ4UkRyemNncUhiUHlNU2g0SjI3TDRENjdyNlczajY5QzVhVTNmalg1WTJMTHRmUTItRWpvaWVZeURZQVVvZ2MzcmZYVjJBZS1IMEtkVDRNZ3BaZUNNU0ltcFhqZFdiNWlvRmVDRUpmamdBaUdlYXo3Zw",
  "googleNewsUrl": "https://news.google.com/articles/CBMihgFBVV95cUxPRGYyaUdWZ2luQW5WZUZ4UkRyemNncUhiUHlNU2g0SjI3TDRENjdyNlczajY5QzVhVTNmalg1WTJMTHRmUTItRWpvaWVZeURZQVVvZ2MzcmZYVjJBZS1IMEtkVDRNZ3BaZUNNU0ltcFhqZFdiNWlvRmVDRUpmamdBaUdlYXo3Zw?hl=en-US&gl=US&ceid=US%3Aen",
  "imageUrl": "https://platform.theverge.com/wp-content/uploads/sites/2/2026/09/firefox-project-nova-redesign-promo.webp?quality=90&strip=all&crop=0,0,84.3,100",
  "authors": [
    "Stevie Bonifield"
  ],
  "storyId": "channel_story_360:CAAqNggKIjBDQklTSGpvSmMzUnZjbmt0TXpZd1NoRUtEd2lJeTZ1SEVoSGNVaXI2UG1tN2VDZ0FQAQ",
  "relatedArticles": [],
  "publishedAtPrecision": "datetime",
  "query": null,
  "topic": "TECHNOLOGY",
  "inputType": "topic",
  "edition": "US:en",
  "position": 1,
  "scrapedAt": "2026-09-29T21:52:31.463Z"
}
```

### How much does it cost?

The Actor is charged per result: each article row pushed to the dataset is one result. Rows where `resolveUrls` successfully found the publisher URL are billed at a higher per-result rate than other rows; it is never billed twice for the same row. Topic and section rows already contain publisher URLs, so they are billed as ordinary results. If resolution fails, the row keeps `googleNewsUrl` and `url` is `null`. The Pricing tab shows the current rates; refer to it before running a large collection. This README does not fix a price because pricing can change. A small `maxItems` value is the simplest way to estimate cost for your own searches.

Publisher URL resolution adds requests and typically makes search runs longer. A plain RSS search can return many headlines in one request, while URL resolution fetches a Google News article page for each selected result and sends small batches to Google News for the final links. Topic pages often provide publisher links in their embedded data and do not need that extra step. Wide date windows and multiple editions also raise request counts. Use the smallest input that answers your question, then expand it once you have inspected the dataset.

### Use with AI agents (MCP)

An AI agent can discover and call this Actor through Apify MCP. Configure the MCP server URL with the Actor's account and name:

```text
https://mcp.apify.com/?tools=axiomworks/google-news-scraper
```

Your agent may need its normal Apify authorization to run Actors. The input and output schemas tell the agent what arguments to send and which fields it can expect. The Actor itself does not require a Google News login.

Example prompts for an agent:

- “Find up to 20 Google News articles about battery recycling in the US edition and return the titles, sources, dates, and publisher URLs.”
- “Collect the latest TECHNOLOGY section headlines for the UK and Germany and group them by publisher.”
- “Search Google News for `site:example.com robotics` between two dates and give me the Google News links for each distinct result.”

Agents should treat returned headlines and linked pages as source data. They may summarize or compare the metadata, but the Actor does not retrieve full publisher article text. Use `sourceUrl` to identify the Google News response behind each row. If a publisher URL is absent, an agent can still cite the Google News link and should not infer a destination.

### Integrations and API

You can run the Actor on a schedule, export its dataset to supported Apify integrations, or call it from your own application. The examples below show the same small input. Provide your Apify token through your normal secret management. Do not put tokens in public code or exported datasets.

Python with the Apify client:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/google-news-scraper").call(
    run_input={"queries": ["battery recycling"], "maxItems": 20}
)
for article in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(article["title"], article.get("url"))
```

JavaScript with the Apify client:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/google-news-scraper').call({
  queries: ['battery recycling'], maxItems: 20,
});
for await (const article of client.dataset(run.defaultDatasetId).iterateItems()) {
  process.stdout.write(`${article.title} ${article.url ?? article.googleNewsUrl}\n`);
}
```

cURL through the Apify API:

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["battery recycling"],"maxItems":20}' \
  'https://api.apify.com/v2/acts/axiomworks~google-news-scraper/run-sync-get-dataset-items'
```

The synchronous cURL endpoint is useful for short jobs. Larger date ranges and URL-resolved searches may take longer; for those, start a run and fetch its dataset when it finishes. A scheduled run can refresh the same search repeatedly. Google News ordering and publisher links may change between runs, so use the stable article ID when joining datasets over time.

### FAQ

**Why did I get fewer items than `maxItems`?** Google News returned fewer distinct articles for your inputs, or some responses repeated the same articles. The cap limits output; it does not make Google News supply a minimum.

**Why is `url` empty?** A search record needs a successful Google News URL resolution. If it fails, use `googleNewsUrl`. Topic records usually have publisher URLs already.

**Does the Actor download article bodies?** No. It collects headline metadata and links from Google News. It does not request publisher hosts, paywalled pages, or article text.

**Can I use a topic URL?** Yes, if it is an HTTPS URL under `news.google.com/topics/`. The Actor applies each selected edition to the topic path.

**How do dates work?** Provide both `dateFrom` and `dateTo` in `YYYY-MM-DD` form. The Actor searches daily windows from the first date through the last. Google News determines which results match those operators.

**Does the Actor need a Google login?** No. It uses publicly accessible Google News responses. Access can still vary by region, network, and Google News availability.

### Is it legal to scrape Google News?

The Actor gathers public headline metadata and links. Google News and publisher content may be protected by terms, copyright, database rights, or local law. Check the rules that apply to your use and location, especially if you plan to republish results or run at scale. This Actor is not affiliated with or endorsed by Google News, Google, or any publisher. It does not provide legal advice. Its output does not grant rights to the underlying articles. Use modest limits and respect publishers when following links outside this Actor.

### Feedback

If a field disappears or publisher URL resolution stops working, report the affected input, edition, and a Google News link in the Actor's Issues tab. Google News can change its RSS format, topic data, and link resolution protocol. A short reproducible example helps identify whether the source changed or a specific query has no results. For questions about run settings, include the input JSON without credentials. Feedback on missing sections, ambiguous dates, or output fields is also welcome through the same tab.

# Actor input Schema

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

Keyword searches, one per list item, e.g. \["nvidia earnings", "climate change"]. Google operators work: quotes, OR, -term, site:reuters.com, intitle:, when:7d, after:2026-01-01. Each query returns up to 100 articles per edition per feed window. Provide at least one of queries, topics or topicUrls. Empty or blocked targets produce no rows and the run continues.

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

First day of a date range for queries, e.g. 2026-09-01. Must be used together with dateTo. The range is searched in daily windows to get past the 100-articles-per-query cap. Overrides timeRange.

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

Last day (inclusive) of the date range, e.g. 2026-09-07. Must be on or after dateFrom and used together with it.

## `timeRange` (type: `string`):

Only return articles from a recent period: any, 1h, 1d, 7d, 30d or 1y (default any). Applies to queries only and is ignored when dateFrom/dateTo are set. Example: 7d.

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

Standard Google News sections to collect, e.g. \["TECHNOLOGY", "BUSINESS"]. Allowed: TOP_STORIES, WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH (case-insensitive). Returns up to ~200 articles per section per edition with publisher URLs.

## `topicUrls` (type: `array`):

Full Google News topic page URLs, including company, person and place topics, e.g. \["https://news.google.com/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGRqTVhZU0FtVnVHZ0pWVXlnQVAB"]. Must be https://news.google.com/topics/... links; copy them from the browser address bar.

## `editions` (type: `array`):

Google News editions as language-COUNTRY codes, e.g. \["en-US", "de-DE"]. Allowed: en-US, en-GB, en-IN, en-AU, de-DE, fr-FR, es-ES, it-IT, pt-BR, ja-JP (default \["en-US"]). Each edition is fetched separately; the output field edition shows Google's form, e.g. US:en.

## `resolveUrls` (type: `boolean`):

If true, keyword-search results get the real publisher article URL in url (otherwise url is null and only googleNewsUrl is set). Slower and billed at the higher per-result rate (see Pricing tab). Section and topic results always include url. Default false.

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

Maximum articles for each query or topic in each edition, 1-5000 (default 100). Example: 50. A single query returns at most 100 articles unless dateFrom/dateTo are set.

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

Hard cap on articles in the whole run across all queries, topics and editions, 1-20000 (default 100). Example: 20 for a quick test.

## `dedupeBy` (type: `string`):

How to remove repeats: url (default), googleNewsId, or none. Stable Google News IDs are always unique within a run, including when none is selected.

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

Apify Proxy settings for requests to Google News. Default {"useApifyProxy": true} (datacenter) works for most runs; change it only if requests are blocked.

## `topicIds` (type: `array`):

Google News topic IDs beginning CAA, copied from the final path component of a /topics/ URL. Alternative to topicUrls; results share maxItems with all other targets. Default empty.

## `publishedAfter` (type: `string`):

Only save articles published strictly after this ISO date or timestamp, e.g. 2026-10-01T12:00:00Z. Date-only values use midnight UTC. Applies to searches and topics after retrieval; does not expand Google coverage. Default empty (no cutoff).

## Actor input object example

```json
{
  "queries": [
    "nvidia earnings"
  ],
  "timeRange": "any",
  "topics": [],
  "topicUrls": [],
  "editions": [
    "en-US"
  ],
  "resolveUrls": true,
  "maxItemsPerQuery": 100,
  "maxItems": 20,
  "dedupeBy": "url",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "topicIds": [],
  "publishedAfter": ""
}
```

# Actor output Schema

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

Dataset of article metadata.

# 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 = {
    "queries": [
        "nvidia earnings"
    ],
    "editions": [
        "en-US"
    ],
    "resolveUrls": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/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 = {
    "queries": ["nvidia earnings"],
    "editions": ["en-US"],
    "resolveUrls": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/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 '{
  "queries": [
    "nvidia earnings"
  ],
  "editions": [
    "en-US"
  ],
  "resolveUrls": true,
  "maxItems": 20
}' |
apify call axiomworks/google-news-scraper --silent --output-dataset

```

## MCP server setup

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