# Google News Scraper ($2.29/1K with publisher URLs) (`tsutseisoftware/google-news-scraper`) Actor

Scrape Google News by keyword, topic, local news or URL in all 84 editions: title, publisher, decoded publisher URL, date, description, image, author. Searches past the 100-result limit, optional full text, new-article alerts to Slack, Discord, Telegram. Unofficial.

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

## Pricing

from $0.19 / 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.
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: Articles, Publisher URLs & News Alerts

Get news articles from **Google News** as clean structured data: search by **keywords** (with all Google operators), read **topics** (world, business, technology, sports…), **top stories** and **local news** of any city, or paste any **Google News URL**, in all **84 editions** of Google News (country and language), Czech and Slovak included. For each article you get the headline, publisher, **the real publisher URL** (decoded from the Google News link), publication time, description, main image, author, keywords and the related coverage Google groups with it, and optionally the **full article text**. Built for media monitoring, PR and brand teams, researchers and AI pipelines.

**$2.29 per 1,000 articles with publisher URLs (the default), $1.49 without.** Google News links no longer contain the publisher's URL; the actor finds it for every article (100 % of the articles in our live test) and caches decoded URLs in your account, so repeated runs are faster. The decoding adds $0.80 per 1,000, and only for articles whose URL was found, so an article with its publisher URL costs **$2.29 per 1,000** ($0.99 on Gold); other scrapers charge $2.30 and more with URLs ($1.00 and more on Gold).

**More than 100 articles per keyword.** Google answers at most about 100 articles per search, and fewer for a long date range. **Expanded search** reads the search day by day (newest first) and tells you which days still had Google's maximum.

**News alerts built in.** Schedule it with **Monitoring: only new articles** and you get only articles not returned before (seen articles are not charged), sent to **Slack, Discord, Telegram, WhatsApp** or your **webhook** after each run.

### Why use this Google News scraper?

- 🔗 **Real publisher URLs** in `url` (tracking parameters removed), the Google link in `googleUrl`, and `urlResolved` saying which one you got. Articles Google doesn't let the actor decode don't pay the URL part of the price.
- 🔎 **Every way to search:** keywords with Google operators (`"exact phrase"`, `OR`, `-word`, `site:`, `intitle:`, `when:`, `after:`, `before:`), plus switches for **exact phrase**, **keywords in the title only**, **exclude words**, **only these publishers**, **exclude publishers**, **timeframe** (past hour to past year) and a **date range**.
- 📰 **Topics, top stories and local news** of any edition, hashed topic and section URLs, publication URLs and Google News RSS URLs you paste.
- 🌍 **All 84 editions** (United States, United Kingdom, Germany, France, Czechia, Slovakia, Poland, Brazil, Japan…), several in one run.
- 📈 **Expanded search** past Google's ~100-article limit, with honest completeness reporting.
- 🖼️ **Description, image, author, keywords and update time** from the publisher's page, included in the price.
- 📄 **Full article text** (optional, charged only for articles whose text was extracted): cookie walls, paywall notices and anti-bot pages give no text and no charge.
- 🧩 **Related coverage** of each story (other publishers Google groups with it), with their publisher URLs when known.
- ♻️ **Duplicates under control:** an article found by several keywords or editions is saved once; **Skip similar stories** keeps one article per story (same or nearly the same headline, and Google's own grouping); `storyId` lets you group copies yourself.
- ↕️ **Sort** by Google's order (relevance), newest or oldest first; **Max articles** and **Max articles per source**.
- 🔔 **Monitoring and alerts:** only new articles (optionally updated headlines), Slack, Discord, Telegram, WhatsApp, webhook (Zapier, Make, n8n).
- 📊 **Free run summary** (SUMMARY record): articles per keyword, topic and publisher, top domains, how the URLs were found, which searches or days hit Google's limit.
- 🤖 **Compact output** for AI agents and MCP clients.
- 🔒 **Privacy first:** e-mails and phone numbers in descriptions and texts are replaced with `[e-mail removed]` / `[phone removed]`. Publisher pages are read at most once a second per website.

#### How it compares with other Google News scrapers

An honest comparison with the Google News scrapers in the Store (their input schemas checked on 2026-11-12), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Keywords, topics, section URLs, editions, timeframe, date range | yes | the better ones too |
| Price per 1,000 articles with publisher URLs (default) | **$2.29** (Bronze $1.99, Silver $1.55, Gold $0.99), no extra platform costs | from $2.30 (Gold from $1.00) |
| Price per 1,000 articles without publisher URLs | **$1.49** (Bronze $1.19, Silver $0.75, Gold $0.19) | from $1.50 (Gold from $0.90) |
| Publisher URL decoding | **$0.80 per 1,000**, only for decoded articles | an option at $0.50–1.50 per 1,000 extra, or included in a price of $2.30–4 |
| Exact phrase, title only, exclude words, include and exclude publishers, sorting, dedupe | yes | one has them all, most a few |
| More than 100 articles per keyword | yes, day by day, with the days still at the limit reported | one |
| Local news of a place, top stories of every edition, all 84 editions | yes | partly |
| Description, image, author, keywords | yes, included | description and image in some |
| Full article text | optional, $0.30 per 1,000, charged only when extracted | one, $0.50 per 1,000 |
| Monitoring of new articles with Slack, Discord, Telegram, WhatsApp, webhook alerts | yes | one small monitor actor |
| Named entities | no (publisher keywords instead, see FAQ) | one |

### What data can you get?

| Field | Example |
|---|---|
| `title`, `publisher`, `publisherUrl` | Jensen Huang's looming ouster triggers an AI earthquake, Axios, https://www.axios.com |
| `url`, `urlResolved`, `domain` | https://www.axios.com/2026/11/12/jensen-huang-nvidia-board, true, axios.com |
| `googleUrl`, `articleId` | https://news.google.com/read/CBMiakFV… |
| `publishedAt`, `modifiedAt` | 2026-11-12T10:08:23Z |
| `description`, `imageUrl`, `author`, `keywords` | the article's summary, main image, byline and tags |
| `relatedArticles`, `relatedCount`, `storyId` | other coverage of the story (title, publisher, links) |
| `query`, `topic`, `sourceType`, `sourceLabel`, `rank` | the keyword or topic it came from and its position |
| `edition`, `language`, `country`, `textLanguage` | US:en, en, US |
| `fullText`, `fullTextLength` | with **Full article text** |
| `changeType`, `firstSeenAt` | with monitoring |

### How to scrape Google News

1. Open the actor in Apify Console and enter **Search keywords** (or pick **Topics**, add **Local news** places or paste **Google News URLs**).
2. Choose the **Editions** (default United States, English).
3. Optionally narrow it down: **Timeframe** or dates, publishers, excluded words, **Expanded search** for more than 100 per keyword.
4. Set **Max articles** and click **Start**.
5. Download the articles as JSON, CSV or Excel, or get them through the API.

### Use cases

#### Latest news about a company, with publisher URLs

```json
{ "searchQueries": ["Nvidia"], "timeframe": "1d", "maxItems": 100 }
```

#### Czech and Slovak news about elections

```json
{ "searchQueries": ["volby"], "editions": ["CZ:cs", "SK:sk"], "timeframe": "7d", "maxItems": 200 }
```

#### Every article about a topic in October, past the 100 limit

```json
{ "searchQueries": ["electric cars"], "exactPhrase": true, "dateFrom": "2026-10-01", "dateTo": "2026-10-31",
  "expandedSearch": true, "maxItems": 0 }
```

#### Brand monitoring: new mentions every hour, to Slack

```json
{ "searchQueries": ["\"Acme Corp\"", "\"Acme\" CEO"], "timeframe": "1d", "onlyNewArticles": true,
  "monitoringKey": "acme", "slackWebhookUrl": "https://hooks.slack.com/services/…", "maxItems": 0 }
```

#### Only from selected publishers, with the full text

```json
{ "searchQueries": ["central bank"], "onlyPublishers": ["reuters.com", "apnews.com", "bbc.co.uk"],
  "includeFullText": true, "maxItems": 50 }
```

#### Top stories and business news of Germany, one article per story

```json
{ "topics": ["TOP_STORIES", "BUSINESS"], "editions": ["DE:de"], "dedupeSimilarStories": true, "maxItems": 0 }
```

#### Local news of Brno and Ostrava

```json
{ "locations": ["Brno", "Ostrava"], "editions": ["CZ:cs"], "maxItems": 60 }
```

#### Decode Google News links you already have

```json
{ "startUrls": [{ "url": "https://news.google.com/rss/articles/CBMiakFVX3lxTE94ak4xcTZteHBzaGNaXzhfWGZ0MzJ0R2VCOEJQSUF0eVhrWUZmUWx6TVhFOGZmVkdOSG1rdm1KbkZKV3YxTTloUnlNeDdTZjRxeHplWmVFaXZ4bUNuYndJRV9zdm9jb1lfZlE?oc=5" }] }
```

A link alone has no headline, publisher or date in Google's answer: they come from the publisher's page, so keep **Description, image and author** on (the default) to get them.

#### Small rows for an AI agent

```json
{ "searchQueries": ["AI regulation EU"], "timeframe": "7d", "compact": true, "includeArticleDetails": false, "maxItems": 30 }
```

### How it works

#### Publisher URLs

Google News article links redirect to the publisher in a browser, but the link itself no longer contains the URL. The actor finds the publisher URL of every article and caches decoded URLs in your account, so repeated runs are faster.

When Google limits the decoding, it is retried once a little later, never from another IP address; if Google keeps limiting it, the rest of the articles keep their Google link (`urlResolved: false`), the status message says how many, and the **Publisher URL** part of the price is not charged for them. In monitoring mode those new articles are not saved at all, so the next run returns them with their URL. You can turn decoding off (**Publisher URL**) for the fastest and cheapest run.

#### Searches and the 100-article limit

A Google News search answers at most about 100 articles, and for a range of several days fewer than its days give one by one (in our test, 7 days gave 93 articles, the same 7 days read day by day 212). **Expanded search** therefore reads every day of the range separately, newest first, and stops reading more days once **Max articles** is covered. Google's dates have no time of day, so a day that still answers close to Google's maximum may have more: the status message and SUMMARY (`fullDays`) list those days. Without expanded search, a search close to the limit gets a hint that there are probably more.

#### Page data and full text

With **Description, image and author** (on by default) the actor reads each article's page on the publisher's website, at most one page per second per website. Some large publishers reject robots: those articles keep these fields empty (anti-bot pages are never solved). **Full article text** also extracts the article's text.

#### Monitoring mode explained

With **Monitoring: only new articles**, the actor remembers the articles of every run in your account under your **Monitoring key** (60 days). The next run with the same key saves only articles it has not returned before; seen ones are not saved and not charged, and each Google News page checked costs only the small **Monitoring page** fee. With **Monitoring: include updated articles**, an article seen before whose headline changed comes back with `changeType: "updated"`.

#### Notifications (news alerts)

Set a Slack, Discord, Telegram or WhatsApp channel or a webhook and each run sends the saved articles (headline, publisher, time and link, at most 50) when it saved something.

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

**$2.29 per 1,000 articles with publisher URLs (default), $1.49 without.** The actor uses pay-per-event pricing: a price per saved article (the $1.49 shown in the Store), the publisher URL on top ($0.80 per 1,000, only for articles whose URL was found), and small fees that are charged only for what was delivered. Prices per 1,000 on the free plan (the **Pricing** tab has the current ones and the plan discounts):

| Event | Price | When |
|---|---|---|
| Article saved in the dataset | $1.49 per 1,000 (Bronze $1.19, Silver $0.75, Gold and up $0.19) | every saved row |
| Publisher URL | + $0.80 per 1,000 | a saved article whose publisher URL was decoded (or found in your cache); articles that keep only the Google link don't pay it. An article with its URL: **$2.29** (Bronze $1.99, Silver $1.55, Gold $0.99) |
| Full text | + $0.30 per 1,000 | a saved article whose text was extracted (**Full article text**); pages without readable text pay nothing |
| Monitoring page | $0.30 per 1,000 pages checked | monitoring mode: every Google News page checked (one per keyword, topic or place in each edition; with expanded search one per day), so a check without news costs almost nothing |
| Extra page | $0.30 per 1,000 | if the saved articles don't cover a run's cost (e.g. a search that finds nothing, an expanded search over many days with few articles, filters that keep few articles, or a run where Google or the websites keep rejecting requests), the difference is charged as small extra page units; the run's charges show how many. A run with a **RESIDENTIAL** proxy pays its proxy traffic this way too. A normal run pays nothing here. |
| Notification | $0.001 per run | once per run that sent its notification (all channels together) |
| Actor start | $0.002 per run | the start of the run |

Example bills (free plan; Gold in brackets):

- **100 articles of a search with publisher URLs:** 100 × $0.00229 + $0.002 = **$0.23** ($0.10).
- **1,000 articles with publisher URLs:** **$2.29** ($0.99).
- **1,000 articles with publisher URLs and full text** (text extracted for all): 1,000 × ($0.00229 + $0.0003) = **$2.59** ($1.29).
- **1,000 articles without publisher URLs** (**Publisher URL** off): **$1.49** ($0.19).
- **Hourly brand monitoring, one keyword, 3 new articles per run, Slack message:** 1 page checked × $0.0003 + 3 × $0.00229 + $0.001 + $0.002 = **$0.010** per run, about $0.24 a day.

You pay no extra platform costs (compute, traffic) on top of these prices. Description, image, author, keywords, related coverage and the SUMMARY record are free. Filtered-out, duplicate and (in monitoring mode) seen articles are not charged. You can set a maximum cost per run; the actor stops when it is reached and reads no full text it could not charge.

### Input example

```json
{
  "searchQueries": ["artificial intelligence"],
  "editions": ["US:en"],
  "timeframe": "7d",
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "google-news:CBMiakFVX3lxTE94ak4xcTZteHBzaGNaXzhfWGZ0MzJ0R2VCOEJQSUF0eVhrWUZmUWx6TVhFOGZmVkdOSG1rdm1KbkZKV3YxTTloUnlNeDdTZjRxeHplWmVFaXZ4bUNuYndJRV9zdm9jb1lfZlE",
  "articleId": "CBMiakFVX3lxTE94ak4xcTZteHBzaGNaXzhfWGZ0MzJ0R2VCOEJQSUF0eVhrWUZmUWx6TVhFOGZmVkdOSG1rdm1KbkZKV3YxTTloUnlNeDdTZjRxeHplWmVFaXZ4bUNuYndJRV9zdm9jb1lfZlE",
  "source": "google-news",
  "title": "Jensen Huang's looming ouster triggers an AI earthquake",
  "publisher": "Axios",
  "publisherUrl": "https://www.axios.com",
  "domain": "axios.com",
  "url": "https://www.axios.com/2026/11/12/jensen-huang-nvidia-board",
  "urlResolved": true,
  "googleUrl": "https://news.google.com/read/CBMiakFVX3lxTE94ak4xcTZteHBzaGNaXzhfWGZ0MzJ0R2VCOEJQSUF0eVhrWUZmUWx6TVhFOGZmVkdOSG1rdm1KbkZKV3YxTTloUnlNeDdTZjRxeHplWmVFaXZ4bUNuYndJRV9zdm9jb1lfZlE",
  "publishedAt": "2026-11-12T10:08:23Z",
  "description": "Nvidia's board is weighing whether its co-founder can stay on…",
  "imageUrl": "https://images.axios.com/….jpeg",
  "author": "Ina Fried",
  "keywords": ["Nvidia", "Jensen Huang"],
  "relatedArticles": [
    { "title": "Nvidia shares slide as board weighs CEO's future", "publisher": "Reuters",
      "googleUrl": "https://news.google.com/read/CBMi…", "url": "https://www.reuters.com/…" }
  ],
  "relatedCount": 6,
  "storyId": "5f1c2a9e0b7d4c31",
  "similarCount": null,
  "rank": 1,
  "sourceType": "topic",
  "query": null,
  "topic": "BUSINESS",
  "sourceLabel": "topic BUSINESS",
  "sourceUrl": "https://news.google.com/rss/headlines/section/topic/BUSINESS?hl=en-US&gl=US&ceid=US:en",
  "edition": "US:en",
  "language": "en",
  "country": "US",
  "pageFetched": true,
  "textLanguage": "en",
  "fullText": null,
  "fullTextLength": null,
  "modifiedAt": "2026-11-12T11:30:00Z",
  "changeType": null,
  "firstSeenAt": null,
  "scrapedAt": "2026-11-12T12:00:00Z"
}
```

### Limitations

- **Measured fill rates** (live runs of 2026-11-12, 514 articles: 424 from the US edition, 45 Czech, 45 Slovak): publisher URL 100 %; the publisher's page read for 82 % (US 79 %, Czech and Slovak 100 %), description 79 %, image 80 %, author 69 %, update time 68 %, publisher keywords 44 %. In runs on Apify some publishers reject more requests (US articles, 13 November: page read and description 70 %, author 50 %); the publisher URL itself is not affected. Full text was extracted for 68 % of 240 articles (83 % of the pages that could be read; Czech and Slovak 82 %, US 63 %). Large publishers such as Reuters, Bloomberg, The Wall Street Journal, Forbes or The Economist reject robots, and some pages are behind cookie walls or paywalls or are video pages.
- `publishedAt` is Google's time. A search's `rank` is Google's relevance order.
- Google gives the related coverage mainly for topics, top stories and local news; searches have it only rarely.
- **Max articles** is the total of the run: the sources are read in order (each keyword in each edition), so with several editions and a small limit the first edition can fill it. Use **Max articles per source** to get articles from every keyword and edition.
- **Published to**: Google counts the day in Pacific time, so a few articles from the first hours of the next day (UTC) can come too.
- A search answers at most about 100 articles; use **Expanded search** for more (a single day is the finest slice Google offers).
- A publication URL returns the publisher's articles. A "full coverage" story URL isn't supported and ends with a clear message.
- Full text is the text of the page as the publisher serves it to a robot: paywalled articles give only their free part or no text; captions, related links and comments are left out, a short teaser paragraph in a separate header block can be missing.
- Descriptions and texts can name people (journalists, people in the news); e-mails and phone numbers are removed, names are not.
- No proxy needed. A page Google rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. It never solves CAPTCHAs.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/google-news-scraper").call(run_input={
    "searchQueries": ["Nvidia"], "timeframe": "1d", "maxItems": 50,
})
for article in client.dataset(run.default_dataset_id).iterate_items():
    print(article["publishedAt"], article["publisher"], article["title"], article["url"])
```

### Troubleshooting

- **"no articles: …"**: Google found nothing; check the keyword in the Google News search box of the same edition, and the timeframe.
- **"reached Google's maximum of ~100 articles"**: turn on **Expanded search**, or narrow the search (timeframe, publishers).
- **`urlResolved: false`**: Google limited the decoding in this run (the status message says so); run again later, decoded URLs are kept so the next run decodes only the rest.
- **Empty description or image**: the publisher's website rejected the request (the status message counts them).
- **"rejecting requests"**: try again later; if it keeps happening, set **Proxy configuration** to Apify Proxy (automatic group).

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More news and trend scrapers

The same clean output and alerts for another news or trend source:

- [Google Trends Scraper](https://apify.com/tsutseisoftware/google-trends-scraper): interest over time, by region and city, related queries, Trending now, keyword alerts and more than 5 terms on one scale
- [Telegram Channel Scraper](https://apify.com/tsutseisoftware/telegram-channel-scraper): posts of public Telegram channels with views, reactions and media, any date range, new, edited and deleted post alerts

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape Google News?

It reads only publicly available data (Google News and the publishers' public article pages), without logging in, at most 150 Google requests per minute and one page per second per publisher website, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. It removes e-mails and phone numbers from descriptions and texts. Google's terms say its feeds are for personal, non-commercial use in a feed reader, and publishers' terms and copyright apply to their articles and texts: you are responsible for how you use the data (copyright, database rights, GDPR and the websites' terms); storing or republishing full texts usually needs the publisher's permission. If in doubt, consult a lawyer. This actor is not affiliated with Google or with any publisher.

#### Why is the publisher URL decoded at all?

Google News links point to `news.google.com` and open the publisher's page only in a browser. Most tools that read Google News give you only that link. This actor gives the publisher's own URL, so you can open, deduplicate or analyze the articles by website. The decoding costs $0.80 per 1,000 articles whose URL was found, so an article with its URL costs $2.29 per 1,000 ($0.99 on Gold), less than the other Google News scrapers charge with URLs; turn **Publisher URL** off for $1.49 ($0.19 on Gold) and the fastest run. Articles Google did not let the actor decode keep their Google link and cost $1.49 too.

#### Can I get named entities (people, organizations, places)?

Not as a separate extraction: reliable entities need a language model that would make every run slower and more expensive (a model for 84 languages does not fit the small, fast container this actor runs in), and a list of capitalized words is mostly noise. What you get for free is `keywords`: the tags the publisher itself gave the article (44 % of articles in our measurement), which name the people, companies and places it is about.

#### How many articles can I get?

About 100 per keyword and edition in one search; with **Expanded search** about as many per day of the date range. Topics and top stories have 30–70 articles each, local news up to about 70.

#### Do I need a proxy?

No. Google News answers the Apify servers directly. If Google starts rejecting the requests, try Apify Proxy (automatic group). A RESIDENTIAL proxy works too, but its traffic is paid as **Extra page**.

#### Does it work for Czech and Slovak news?

Yes: choose the editions **Czechia (Čeština)** and **Slovakia (Slovenčina)**. Search keywords, topics and local news (e.g. Brno, Košice) work the same way, and page data and full text work for Czech and Slovak publishers (iDNES.cz shows robots a consent wall, so its articles get page data but no text).

#### Can I use it from an AI agent or through MCP?

Yes. Apify's MCP server (mcp.apify.com) exposes every actor in the Store as a tool; **Compact output** keeps the rows small for a model's context.

***

Also known as a Google News API, Google News RSS scraper, Google News link decoder, news monitoring and media monitoring tool, "Google News scraper Czech" ("zprávy z Google News", "monitoring médií").

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/google-news-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

One search per line, as in the Google News search box. Google operators work: "exact phrase", OR, -word, site:reuters.com, intitle:word, when:7d, after:2026-11-01, before:2026-11-08. A search answers at most about 100 articles (Google's limit): turn on "Expanded search" for more. At most 100 lines.

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

Google News sections of every chosen edition: top stories (the edition's home page), world, nation, business, technology, entertainment, sports, science, health (30-70 articles each, with related coverage).

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

Local news of a city, region or country, e.g. "Prague", "Brno", "Bratislava", "London", "Austin, Texas" (the "Local news" section of Google News). At most 50.

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

Any news.google.com page: a search (https://news.google.com/search?q=bitcoin\&hl=en-US\&gl=US\&ceid=US:en), a topic or section, including hashed ones (https://news.google.com/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGx6TVdZU0FtVnVHZ0pWVXlnQVAB), top stories, local news, a publication (read as a site: search of its domain), the RSS URL of any of them, or Google News article links (https://news.google.com/rss/articles/CBMi...) to get their publisher URL and page data. The edition in the URL (hl, gl, ceid) is kept.

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

Google News editions to read every keyword, topic and place in (each is a separate source). All 84 editions of Google News; e.g. Czechia (cs), Slovakia (sk), Germany (de), United Kingdom (en). At most 10.

## `exactPhrase` (type: `boolean`):

Search every keyword as an exact phrase ("electric cars").

## `titleOnly` (type: `boolean`):

Only articles with every keyword word in the headline (intitle:).

## `excludeWords` (type: `array`):

Leave out articles with these words (-word in searches; in the headline for topics and local news).

## `onlyPublishers` (type: `array`):

Website domains, e.g. reuters.com, bbc.co.uk, idnes.cz (site: in searches; the publisher's domain for topics and local news). Without keywords or topics: the newest articles of these publishers.

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

Website domains to leave out, e.g. yahoo.com, msn.com (-site:).

## `timeframe` (type: `string`):

Only articles published within this time (when: in searches).

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

Only articles published on or after this day (YYYY-MM-DD; after: in searches). Use this or "Timeframe".

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

Only articles published on or before this day (YYYY-MM-DD; before: in searches). Google counts the day in Pacific time, so a few articles from the first hours of the next day (UTC) can come too.

## `expandedSearch` (type: `boolean`):

Google answers at most ~100 articles per search. With this on, every search is read day by day (the dates above, the timeframe, or the last 30 days; newest days first and only as many as Max articles needs), and articles are deduplicated. The status message names the days that still had ~100 (Google gives no finer dates). Days that add few saved articles can add small "Extra page" charges (see Pricing).

## `sortBy` (type: `string`):

Order of the articles of every source (applied before "Max articles per source").

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

Maximum number of articles saved in the run (the sources are read in order, so with several editions use "Max articles per source" too). You pay per saved article. 0 = no limit.

## `maxItemsPerSource` (type: `integer`):

Limit for each keyword, topic, place and URL (in each edition). 0 = no limit.

## `dedupeAcrossSources` (type: `boolean`):

Save an article found by several keywords, topics or editions once (the first source). Off: one row per article and source (each charged).

## `dedupeSimilarStories` (type: `boolean`):

Save one article per story: skip later articles with the same or nearly the same headline (syndicated copies, small edits) and the related coverage Google groups with a saved article. Skipped articles are not charged; "similarCount" says how many were skipped.

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

Decode the Google News link of every article to the publisher's URL (+$0.80 per 1,000 decoded articles: $2.29 per 1,000 with the URL, $1.49 without, see Pricing). Decoded URLs are cached in your account, so repeated runs are faster. When Google limits the decoding, articles keep their Google link (urlResolved false) and the "Publisher URL" part of the price is not charged.

## `includeArticleDetails` (type: `boolean`):

Read every article's page on the publisher's website: description, main image, author, keywords and update time (not charged extra). Some publishers reject robots (anti-bot pages are never solved): those articles keep these fields empty.

## `includeFullText` (type: `boolean`):

Read the whole article page and extract the text, e-mails and phone numbers removed. Extra charge "Full text" only for articles whose text was extracted (see Pricing); paywalls, cookie walls and rejected pages give no text and no charge.

## `fullTextMaxLength` (type: `integer`):

Shorten the text to about this many characters (at a paragraph or sentence end). 0 = whole text.

## `onlyNewArticles` (type: `boolean`):

Return only articles not returned by an earlier run with the same Monitoring key. Articles seen before are not saved and not charged; every Google News page checked costs the small "Monitoring page" fee (see Pricing). Seen articles are remembered for 60 days.

## `includeUpdated` (type: `boolean`):

Also return articles seen before whose headline changed (changeType "updated").

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched set of keywords. Empty = "default". The value is stored encrypted.

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...). Stored encrypted.

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `telegramBotToken` (type: `string`):

Token of your Telegram bot (from @BotFather). Used with "Telegram chat ID". Stored encrypted.

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n, your server): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many articles are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no article (e.g. a monitoring run without news).

## `compact` (type: `boolean`):

Keep only the core fields of every row (for AI agents, MCP clients and dashboards). Same price.

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

No proxy by default: Google News answers the Apify servers directly. Apify Proxy (automatic group) only if Google rejects the requests. A RESIDENTIAL proxy works too: its traffic is added as "Extra page" charges (see Pricing).

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "artificial intelligence"
  ],
  "editions": [
    "US:en"
  ],
  "exactPhrase": false,
  "titleOnly": false,
  "timeframe": "any",
  "expandedSearch": false,
  "sortBy": "relevance",
  "maxItems": 20,
  "maxItemsPerSource": 0,
  "dedupeAcrossSources": true,
  "dedupeSimilarStories": false,
  "resolveUrls": true,
  "includeArticleDetails": true,
  "includeFullText": false,
  "fullTextMaxLength": 0,
  "onlyNewArticles": false,
  "includeUpdated": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "compact": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `articles` (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 = {
    "searchQueries": [
        "artificial intelligence"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/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 = {
    "searchQueries": ["artificial intelligence"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

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