# Google News Media Monitoring Scraper - Brand Mention Monitor (`snow_leo_data/google-news-scraper`) Actor

Google News scraper that splits a keyword into day windows: 2070 articles where one plain feed returns 99, measured. Links resolve to the publisher's real address, not a google redirect: 100 of 100 on the default cloud run. 80 editions. Google News API for media monitoring and brand mentions.

- **URL**: https://apify.com/snow\_leo\_data/google-news-scraper.md
- **Developed by:** [Snow Leo Data](https://apify.com/snow_leo_data) (community)
- **Categories:** News, SEO tools, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.90 / 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 — news articles, publisher URLs, 80 editions

Scrape Google News without an API key. This Actor collects **news articles** by
keyword, by topic, by city, or from the top stories of any Google News edition,
and gives you every article with the **publisher URL** — the real link to the
newspaper, not the `news.google.com/rss/articles/CBMi…` redirect that Google
hands out.

It is built for **news monitoring**, **media monitoring**, **brand mentions**,
**press coverage** tracking and **news data** pipelines. Use it as a **Google
News API** replacement, as a **news API** for an agent, as a **news aggregator**
feed, for **news alerts** on **breaking news**, or as a plain **news crawler**
over **Google News RSS**. Everything below is a number you can reproduce with
one command; nothing here is an estimate.

### What this Actor does that a Google News feed cannot

#### Why does a normal Google News scraper stop at 100 articles?

Because the feed does. A Google News RSS feed returns about one hundred items
and never says so — there is no cursor, no page two, and no error. Measured on
2026-09-12:

| feed | articles returned |
|---|---|
| `q=tesla` | 99 |
| `q=apple` | 104 |
| `q=climate change` | 102 |
| `q=economy` | 107 |
| topic `TECHNOLOGY` | 56 |
| topic `BUSINESS` | 70 |
| city `Chicago` | 70 |

One competing Google News scraper says it plainly in its own README: *"100
articles per query — Google News RSS feeds return up to ~100 articles per
query."* Another offers `maxArticles: 0` for "no limit" over the same feed.

**This Actor splits a keyword search into day windows.** Google News search
understands the `after:` and `before:` operators, so instead of one request for
`tesla` it makes one request per day. The ceiling applies to each window, not to
the search:

| what was asked | requests | unique articles |
|---|---|---|
| `tesla`, plain feed | 1 | 99 |
| `tesla`, 4 day windows | 5 | 309 |
| `tesla`, 30 day windows | 31 | **2070** |

Thirty-one requests, half a minute, **20 times more news articles** than the
feed will give you. Set `daysBack` and the sweep happens by itself. Turn
`breakFeedCap` off and you get exactly what a single feed returns — the run
report then records that the cap was hit, so you always know which of the two
you got.

#### Why is the article URL a google.com link everywhere else?

Since Google re-encrypted its redirects, a Google News feed link looks like
`https://news.google.com/rss/articles/CBMiyAFBVV95cUxPVWlM…`. You cannot store
it, group by domain, feed it to a model, or open it from a spreadsheet reliably.
Decoding it takes a signed call to an internal Google endpoint.

**This Actor resolves every link to the publisher's own article URL.** Measured
on live output: **30 out of 30** articles resolved, all thirty in a single
request. On the first cloud run with the default input: **100 out of 100**.
Sample rows:

```
https://www.bloomberg.com/news/features/2026-09-10/iphone-duo-hands-on-…
https://www.latimes.com/business/story/2026-09-11/is-there-really-10-chance-…
https://apnews.com/article/heat-record-climate-change-sizzle-el-nino-…
```

It needs no proxy and no browser. When a link cannot be resolved, `url` stays
**empty** and `url_resolved` is `false` — the field is never filled with a
Google redirect pretending to be an article link.

#### What does Google News do when it does not know the city?

It lies quietly. Ask for local news of a place Google News has never heard of
and it does not answer with an error or with an empty feed — it returns the
national feed under the name you asked for. Measured:

| requested city | channel Google actually returned | articles | overlap with the real city |
|---|---|---|---|
| `Chicago` | `Chicago - Latest - Google News` | 70 | — |
| `Zzqqxxnotaplace` | **`U.S. - Latest - Google News`** | 64 | **0** |

Sixty-four articles that have nothing to do with the city, delivered as local
news. A scraper that only reads the items cannot tell the difference.

**This Actor compares the channel title with the city you asked for.** When they
disagree, every row is marked `geo_fallback: true`, the run report lists the
swap, and the log says which spelling Google refused to recognise.

#### Which fields does Google News actually publish, and which does it not?

The feed carries the headline, the publisher name, the publisher home page, the
publication time and the article link. It carries **no article summary and no
image**: the `description` element of a Google News item is the headline again
plus the list of other outlets covering the same story.

This Actor does not pretend otherwise. The repeated headline is dropped instead
of being sold to you as a snippet, and the list of other outlets is parsed into
a structured `related` array — headline and link for each outlet that covered
the same story. `related_count` is a cheap relevance signal: a story picked up
by several outlets is rarely noise, and `minRelatedArticles` filters on it.

If you do want the description and the image, switch on `fetchArticleMeta`: the
Actor opens each resolved publisher page and reads `og:description` and
`og:image`. No proxy is used, so some publishers refuse. Measured on 40 live
articles: **26 of the 40 publisher pages answered with both fields**; the rest
returned 403, 401, 402 or timed out. A cloud run over 50 articles filled them
for **36**. The run report gives you `meta_attempted` and `meta_ok` for every
run, so the success rate is a number you see rather than a promise you are
given.

#### How does monitor mode avoid billing you twice?

Turn on `onlyNew`. The Actor remembers the article ids it has already delivered
in a **named** key-value store, which survives between runs, and skips them next
time. A scheduled hourly run over the same keyword therefore pays for the few
articles that are new, not for the same hundred every hour.

A monitor run with nothing new writes **zero rows**, and that is correct
behaviour, not a fault — so the Actor says why: `empty_reason` is set to
`nothing-changed` in the report and the log spells it out. Every legitimate
empty result is named the same way (`filtered-out`, `source-returned-nothing`,
`charge-limit-reached`), so an empty dataset is never silent.

The fingerprint used to spot a rewritten headline deliberately ignores the
resolved URL. Otherwise a run with resolution on and a run with it off would
count the same article as two different ones and the monitor would deliver it
again.

#### How do the filters avoid emptying your dataset?

The dangerous kind of scraper bug is a green run with zero rows: the buyer pays
for the start and gets nothing, and nobody can see why. Two rules keep it out of
this Actor.

**A filter never depends on a field that the current mode does not fill.**
Filtering by publisher uses `publisher_domain`, which the feed supplies in its
`<source url=…>` element, so publisher filters work with URL resolution turned
off. The single filter that does need resolution — `withUrlOnly` — switches
resolution on by itself and says so in the log, instead of silently returning
nothing. So does `fetchArticleMeta`.

**A missing value is not a mismatch.** An article whose publisher Google did not
state passes a publisher filter instead of being thrown away.

**`maxItems` limits the output, not the crawl.** When filters are on, the Actor
collects with headroom and stops counting when it has *delivered* the number you
asked for. Ask for 5 articles from one rare publisher and you get 5, not an
empty dataset with 1100 articles quietly discarded behind it.

### Output

One row per article. Fields Google did not publish stay empty; nothing is
inferred or invented.

| field | what it is |
|---|---|
| `title` | headline with the publisher suffix removed |
| `title_raw` | headline exactly as Google News published it |
| `url` | the publisher's own article URL, resolved |
| `url_resolved` | whether resolution succeeded for this row |
| `google_news_url` | the original `news.google.com` redirect |
| `publisher` | publisher name as Google names it |
| `publisher_domain` | domain, `www.` stripped — group and filter on this |
| `publisher_url` | publisher home page from the feed |
| `description` | `og:description` from the publisher page (`fetchArticleMeta`) |
| `image` | `og:image` from the publisher page (`fetchArticleMeta`) |
| `snippet` | feed text when it carries more than the headline |
| `published_at` | ISO 8601 UTC |
| `published_timestamp` | unix seconds, computed in UTC |
| `related` | other outlets covering the same story: headline and link |
| `related_count` | how many of them |
| `source_type` | `search`, `topic`, `topic_url`, `geo` or `top` |
| `query`, `topic`, `geo` | which input produced this row |
| `geo_fallback` | true when Google swapped your city for the national feed |
| `edition`, `language`, `country` | which Google News edition this came from |
| `article_id` | Google's stable id for the article |
| `change_type` | `NEW` / `UPDATED` / `UNCHANGED` in monitor mode |
| `scraped_at` | when this run collected it |

Two output modes keep the rows small: `compactOutput` cuts to twelve fields for
AI agents and spreadsheets, `excludeEmptyFields` drops keys with nothing in
them.

### Editions

Eighty Google News editions are offered, and all eighty were checked live on
2026-09-12 with the same query: every one returned articles, median 100 per
feed. The edition sets the language of the results and decides which publishers
Google treats as local, so `DE:de` for `wirtschaft` is a different newspaper set
from `AT:de` for the same word.

Covered: United States, United Kingdom, Canada (English and French), Australia,
India (English, Hindi, Bengali, Tamil, Telugu, Marathi, Malayalam, Gujarati,
Kannada), Ireland, New Zealand, South Africa, Singapore, Philippines, Nigeria,
Pakistan, Kenya, Ghana, Tanzania, Uganda, Germany, Austria, Switzerland, France,
Belgium (French and Dutch), Spain, Mexico, Argentina, Chile, Colombia, Peru,
Venezuela, US Spanish, Italy, Netherlands, Portugal, Brazil, Russia, Ukraine
(Russian and Ukrainian), Poland, Czechia, Slovakia, Hungary, Romania, Bulgaria,
Greece, Turkey, Israel, Sweden, Norway, Denmark, Finland, Lithuania, Latvia,
Estonia, Slovenia, Croatia, Serbia, Japan, South Korea, China, Taiwan, Hong
Kong, Thailand, Vietnam, Indonesia, Malaysia, Bangladesh, Egypt, Saudi Arabia,
United Arab Emirates, Lebanon and Iran.

### Input

| input | default | what it does |
|---|---|---|
| `queries` | `artificial intelligence` | search terms; Google operators work |
| `topics` | — | Google's own sections: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH |
| `topicUrls` | — | any topic or section page address copied from news.google.com |
| `geoLocations` | — | city feeds for local news |
| `includeTopStories` | off | the edition's front page |
| `edition` | `US:en` | one of 80 |
| `daysBack` | 7 | how far the day-window sweep goes |
| `breakFeedCap` | on | split by day to pass the ~100 cap |
| `resolveArticleUrls` | on | publisher URL instead of the Google redirect |
| `fetchArticleMeta` | off | description and image from the publisher page |
| `maxItems` | 0 | hard stop on delivered rows |
| `onlyNew` | off | monitor mode with memory between runs |
| `emitUnchanged` | off | deliver known articles again |
| `titleContains` / `excludeKeywords` | — | keep or drop by words in the headline |
| `publishers` / `excludePublishers` | — | keep or drop by domain, subdomains included |
| `publishedWithinHours` | 0 | freshness window |
| `withUrlOnly` | off | only rows with a resolved publisher URL |
| `minRelatedArticles` | 0 | only stories several outlets covered |
| `includeRelatedArticles` | on | keep the related-coverage array |
| `compactOutput`, `excludeEmptyFields` | off | smaller rows |

Search terms accept Google operators: `tesla OR rivian`, `bitcoin -ethereum`,
`"exact phrase"`, `site:reuters.com`, and they combine with the day windows.

### What this Actor does not do

Named plainly, because a limitation you find after paying is worse than one you
read first.

- **No full article text.** Google News does not carry it and this Actor does not
  fetch it. With `fetchArticleMeta` you get the publisher's own description and
  image, at the measured rate above, and nothing more.
- **No proxy, and that has a price.** Roughly a third of publisher pages refuse
  a direct request, so `fetchArticleMeta` leaves those two fields empty on them.
  Feed reading and URL resolution are unaffected — both go through Google itself.
  Measured: 26 of 40 locally, 36 of 50 in the cloud.
- **Topic, city and top-story feeds cannot be swept by day.** Only keyword search
  understands `after:`/`before:`, so those are snapshots of what Google shows
  right now: 56 to 70 articles. The same applies to `topicUrls`, and some topic
  ids that Google prints on its own front page answer 404 to the feed — the run
  report names them rather than leaving you with silence.
- **`related` links are Google redirects.** The outlets covering the same story
  are resolved only if you collect them as articles in their own right.
- **Sentiment, entities and topic models are not included.** You get the news
  data; scoring it is your pipeline's job.

### FAQ

#### Do I need a Google News API key?

No. Google does not publish one — the official Google News API was retired years
ago. This Actor reads the public feeds and needs no key, no token and no
account with Google.

#### How many articles can I get for one keyword?

Measured: 2115 for `tesla` over thirty day windows, against 99 from the plain
feed. The number depends on how much the world writes about your keyword; a busy
term fills every daily window to the cap, a quiet one does not.

#### Is this a Google News API alternative?

It is a replacement for one, with structured JSON or CSV out of the box, the
publisher URL included, and no quota. What it cannot do is give you articles
Google News does not index.

#### How do I set up news monitoring or brand mentions alerts?

Put your brand and your competitors in `queries`, turn on `onlyNew`, and
schedule the Actor hourly or daily in Apify. Each run delivers only articles you
have not seen, so cost follows the news rather than the schedule. Connect it to
Make, n8n, Slack or Google Sheets through the standard Apify integrations.

#### Why is `url` empty on some rows?

Either resolution was switched off, or Google refused to resolve that particular
article. The row keeps `google_news_url` so nothing is lost, and
`url_resolved: false` marks it. Use `withUrlOnly` to drop such rows entirely.

#### Why did my run return zero articles?

The report always says. `filtered-out` means the filters removed everything and
the report names which filter removed how many. `nothing-changed` means monitor
mode found no new articles. `source-returned-nothing` means Google News had no
results for that input — a misspelled search term does this, and so does a
narrow `publishedWithinHours`. `charge-limit-reached` means your spending limit
for the run was already used up.

#### Can I track local news for a specific city?

Yes, with `geoLocations`. Check `geo_fallback` on the rows: if it is true,
Google did not recognise the name and gave you the national feed instead. Try
the spelling Google News itself uses on its site.

#### Does it work for non-English news?

Yes, in all 80 editions, and the results come back in that edition's language.
Search terms should be in the language of the edition: `wirtschaft` for `DE:de`,
`経済` for `JP:ja`.

#### How does the day-window sweep affect cost?

One window is one request. Thirty days for one keyword is thirty-one requests
and roughly half a minute. You pay per delivered article, so the sweep costs you
nothing extra beyond the articles you actually receive — use `maxItems` if you
want a hard ceiling.

#### What happens if the run is interrupted?

Rows are pushed to the dataset in batches as they are collected, and the monitor
memory is written only after a batch has been delivered. An interrupted run
therefore never marks an article as delivered when it was not, and the next run
picks up what was missed.

#### Is scraping Google News legal?

The feeds are public and this Actor collects published journalism metadata:
headlines, publisher names, links and timestamps. It collects no personal data.
You are responsible for complying with copyright, the terms of the publishers
whose pages you open, and any applicable law in your jurisdiction.

#### How fast is it, and what does a run cost in compute?

Measured in the cloud at 512 MB, which is what this Actor is set to run on and
about five times its observed peak of 106 MB:

| run | articles | time | Apify compute |
|---|---|---|---|
| default input, every link resolved | 100 | **6.0 seconds** | $0.000414 |
| 7-day sweep of `tesla`, links resolved | 500 | 116.7 seconds | $0.005915 |
| 50 articles with `fetchArticleMeta` on | 50 | 25.5 seconds | $0.000904 |

That is the platform's compute charge, separate from what you pay per article.
Turning resolution off makes a run several times faster and cheaper: the same
500-article sweep without it took 5.6 seconds.

#### What else is this called?

Also asked for as newsroom monitoring, which is the `publisher` field.

# Actor input Schema

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

What to search Google News for. Google operators work: `tesla OR rivian`, `bitcoin -ethereum`, `"exact phrase"`, `site:reuters.com`. Each term is searched separately, and identical articles found by several terms are delivered once.

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

Curated Google News sections for the chosen edition. A topic feed returns what Google puts on that section's front page — measured 53 to 70 articles — and cannot be split by day, so it is a snapshot, not a sweep.

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

Any topic or section page from news.google.com, e.g. `https://news.google.com/topics/CAAqIQgKIhtDQkFTRGdvSUwyMHZNR3QwTlRFU0FtVnVLQUFQAQ`. Paste the whole address or just the id. Use it for niches with no predefined topic. Some ids Google shows on its own front page answer 404 to the feed; the run report names those instead of returning silence.

## `geoLocations` (type: `array`):

Local news sections, e.g. `Chicago`, `Manchester`, `Munich`. Spell the city the way Google News does: for a name it does not know it silently returns the national feed instead of an error. Those rows are marked `geo_fallback: true` and the run log names the swap.

## `includeTopStories` (type: `boolean`):

Also collect the front page of the chosen edition — the same list Google News shows on news.google.com.

## `edition` (type: `string`):

Which Google News edition to read. All 80 listed here were checked live and returned articles. The edition decides both the language of the results and which publishers Google considers local.

## `daysBack` (type: `integer`):

How far the day-window sweep goes for each search term. One extra day is one extra request and up to 100 more articles. Google News keeps searchable archives far beyond a month, but older days return fewer articles.

## `breakFeedCap` (type: `boolean`):

Split each search term into one request per day so the run is not stopped by the feed cap. Turn it off to get exactly what a single Google News feed returns — faster, about 100 articles per term, and the report says the cap was hit.

## `resolveArticleUrls` (type: `boolean`):

Google News links point at `news.google.com/rss/articles/CBMi…`, not at the publisher. With this on, every article also gets the publisher's own URL in `url`. It costs one extra page read per article; measured 30 out of 30 resolved on live output. With it off, `url` is empty and `url_resolved` is false — the field is never filled with a Google redirect pretending to be an article link.

## `fetchArticleMeta` (type: `boolean`):

Google News feeds carry no article summary and no image — the feed's description field just repeats the headline. With this on, the Actor opens each resolved publisher page and takes `og:description` and `og:image` from it. No proxy is used, so some publishers refuse: measured on 40 live articles, 27 answered and 26 gave both fields. The run report says how many succeeded; the rest keep those fields empty rather than inventing them.

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

Hard stop on how many rows land in the dataset, which is also how many you pay for. This limits the OUTPUT, not the crawl: when your filters are on, the run collects more than this and stops when it has delivered enough. 0 means no limit.

## `onlyNew` (type: `boolean`):

Remembers what earlier runs already delivered and skips it, so a scheduled run pays only for what is genuinely new. Memory lives in a named key-value store and survives between runs. A run with nothing new writes zero rows and says so in the log and in `empty_reason`.

## `emitUnchanged` (type: `boolean`):

Delivers articles marked `UNCHANGED` too. Useful for a full snapshot on every run; it means paying again for rows you already have.

## `titleContains` (type: `array`):

Case-insensitive match against the headline and the snippet. An article passes if it contains at least one of these.

## `excludeKeywords` (type: `array`):

Case-insensitive match against the headline and the snippet. An article is dropped if it contains any of these.

## `publishers` (type: `array`):

Domains such as `reuters.com` or `bbc.com`. Subdomains count, so `bbc.com` keeps `news.bbc.com`. The domain comes from the feed itself, so this works with URL resolution switched off too. Articles whose publisher Google did not state are kept, not dropped — missing data is not a mismatch.

## `excludePublishers` (type: `array`):

Domains to remove from the results, e.g. an aggregator you do not want. Subdomains count.

## `publishedWithinHours` (type: `integer`):

Filters on the publication time from the feed. 0 turns it off. Articles with no publication date are kept.

## `withUrlOnly` (type: `boolean`):

Drops rows where the Google redirect could not be turned into a publisher URL. This needs resolution, so switching it on switches resolution on as well, and the log says so.

## `minRelatedArticles` (type: `integer`):

Google groups coverage of one story and lists the other outlets inside the feed entry. Set 1 or more to keep only stories that several outlets picked up — a cheap relevance signal. 0 turns it off.

## `includeRelatedArticles` (type: `boolean`):

Keeps the `related` array — the other outlets covering the same story, with their headlines. Turn off for a smaller, flatter dataset.

## `compactOutput` (type: `boolean`):

Keeps only headline, URL, publisher, domain, date, snippet and the origin fields. Made for AI agents and spreadsheets that choke on wide rows.

## `excludeEmptyFields` (type: `boolean`):

Removes keys whose value is empty, so rows carry only what Google actually published.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "topics": [],
  "topicUrls": [],
  "geoLocations": [],
  "includeTopStories": false,
  "edition": "US:en",
  "daysBack": 7,
  "breakFeedCap": true,
  "resolveArticleUrls": true,
  "fetchArticleMeta": false,
  "maxItems": 100,
  "onlyNew": false,
  "emitUnchanged": false,
  "titleContains": [],
  "excludeKeywords": [],
  "publishers": [],
  "excludePublishers": [],
  "publishedWithinHours": 0,
  "withUrlOnly": false,
  "minRelatedArticles": 0,
  "includeRelatedArticles": true,
  "compactOutput": false,
  "excludeEmptyFields": false
}
```

# Actor output Schema

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

All collected rows

# 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": [
        "artificial intelligence"
    ],
    "daysBack": 7,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("snow_leo_data/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": ["artificial intelligence"],
    "daysBack": 7,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("snow_leo_data/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": [
    "artificial intelligence"
  ],
  "daysBack": 7,
  "maxItems": 100
}' |
apify call snow_leo_data/google-news-scraper --silent --output-dataset

```

## MCP server setup

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