# Google News Scraper: Full Text, 100+ Results, Monitoring (`kvali/google-news-scraper`) Actor

Scrape Google News by keyword or topic in 48 country and language editions. Get real publisher URLs, more than 100 results per query, optional full article text in clean Markdown, and a monitoring mode that returns only articles you haven't seen yet.

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

## Pricing

from $2.00 / 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

### What does Google News Scraper do?

**Google News Scraper** extracts news articles from [Google News](https://news.google.com) by keyword or by topic, in 48 country and language editions. For every article you get the headline, publisher, **real publisher URL** (not a news.google.com redirect), and publication date. Optionally, it can also return the **full article text** as clean Markdown for AI and analysis.

It's built for three jobs that most Google News scrapers do badly:

- 📈 **More than 100 results per query.** Google News stops at about 100 results per search. This scraper automatically splits your time range into smaller windows, so you can collect **thousands of articles** for one keyword, including historical ones.
- 🔔 **News monitoring that only returns new articles.** Schedule it hourly or daily with *Only new articles* turned on, and each run returns only articles you haven't received before. You don't pay twice for the same article.
- 🤖 **AI-ready full text.** Get the article body as Markdown and plain text, plus author, main image, description and word count, ready for LLMs, RAG pipelines, summarization and sentiment analysis.

No browser, no login, no API key. It uses lightweight HTTP requests, so runs are fast and cheap.

### Why scrape Google News?

Google News aggregates tens of thousands of publishers and ranks the stories that matter. Scraping it lets you:

- **Media monitoring and PR.** Track every mention of your brand, competitors, executives or products across the press.
- **Market and investment research.** Follow news about companies, tickers, industries or commodities, and feed it into dashboards or trading signals.
- **AI and LLM pipelines.** Build news datasets for RAG, fine-tuning, summarization bots or daily briefings.
- **Sentiment and trend analysis.** Measure coverage volume and tone over time for any topic.
- **Newsletters and content curation.** Collect the day's top stories for a niche automatically.
- **Academic and journalism research.** Build historical news datasets for a date range.

### How to scrape Google News

1. Click **Try for free**.
2. Enter one or more **search queries** (for example `openai`, `"electric vehicles"`, `tesla site:reuters.com`) and/or pick **topics** such as Business or Technology.
3. Choose the **country and language**, a **time range**, and how many articles you want per query.
4. Optionally turn on **Get full article text** or **Only new articles**.
5. Click **Start** and download your data as JSON, CSV, Excel or HTML, or get it through the API.

#### Search tips

All Google News search operators work in queries:

| You want | Query |
|---|---|
| An exact phrase | `"interest rates"` |
| Either word | `apple OR microsoft` |
| Exclude a word | `jaguar -car` |
| One publisher only | `nvidia site:bloomberg.com` |
| Word in the headline | `intitle:merger` |

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

This Actor uses simple pay-per-result pricing. There's **no start fee**, and you pay only for what you get:

| Event | Price |
|---|---|
| Article (headline, publisher, real URL, date) | **$2.00 per 1,000 articles** |
| Full article text (only when you turn it on, and only when extraction succeeds) | **$3.00 per 1,000 articles** |

Examples:

- 1,000 headlines with publisher URLs: **$2.00**
- 1,000 articles with full text: **$5.00**
- Monitoring 20 keywords every hour with *Only new articles*: you pay only for articles that are actually new.

Paywalled articles, or pages where the text can't be extracted, are **not charged** for full text. The row still includes the headline, URL and date, and `fullTextStatus` explains what happened.

On the Apify Free plan you get monthly credits, which are enough to try this Actor with thousands of articles.

### Input

Configure everything in the **Input** tab. Here's an example input:

```json
{
    "queries": ["artificial intelligence", "\"interest rates\""],
    "topics": ["BUSINESS"],
    "region": "US:en",
    "timeRange": "7d",
    "maxItemsPerQuery": 300,
    "decodeUrls": true,
    "fetchFullText": false,
    "onlyNew": false
}
```

| Field | What it does |
|---|---|
| `queries` | Keywords to search. Operators like `site:` and `"..."` are supported. |
| `topics` | Headline sections: `TOP`, `WORLD`, `NATION`, `BUSINESS`, `TECHNOLOGY`, `ENTERTAINMENT`, `SPORTS`, `SCIENCE`, `HEALTH`. |
| `region` | Google News edition, for example `US:en`, `GB:en`, `DE:de`, `FR:fr`, `ES:es`, `BR:pt-419`, `JP:ja`, `IN:hi`. 48 editions are available. |
| `timeRange` | `any`, `1h`, `1d`, `7d`, `30d`, `1y` or `custom` (then set `dateFrom` and `dateTo`). |
| `maxItemsPerQuery` | Up to 10,000. Above 100, the time range is split automatically to go past Google's limit. |
| `decodeUrls` | Return real publisher URLs instead of Google redirect links (default: on). |
| `fetchFullText` | Add full article text (Markdown and plain text), author, image and description. |
| `excludeSources` | Skip publishers by domain or name. |
| `onlyNew` + `monitorKey` | Monitoring mode: return only articles that earlier runs with the same monitor name haven't returned. |

### Output

Each article is one item in the dataset. Here's an example with full text turned on (text shortened):

```json
{
    "query": "interest rates",
    "topic": null,
    "region": "US:en",
    "position": 1,
    "title": "What are the financial benefits of higher interest rates? Experts explain",
    "source": "abcnews.com",
    "sourceUrl": "https://abcnews.com",
    "url": "https://abcnews.com/Business/financial-benefits-higher-interest-rates-experts-explain/story?id=136647362",
    "urlResolved": true,
    "googleNewsUrl": "https://news.google.com/rss/articles/CBM...",
    "publishedAt": "2026-09-23T10:12:39.000Z",
    "articleId": "CBMipwFBVV95cUxQWENaZFhIa3pVQlY1OVI1enNT...",
    "scrapedAt": "2026-09-23T12:40:09.306Z",
    "imageUrl": "https://i.abcnewsfe.com/a/991ff620-275c-4ba4-ae91-4a17d6f72a12/wallet-money-as-jt-260922_1790094994995_hpMain_16x9.jpg?w=1600",
    "description": "The Federal Reserve recently raised interest rates for the first time since 2023.",
    "author": "Max Zahn",
    "language": "en",
    "markdown": "A key long-term Treasury rate [hit](https://abcnews.com/Business/rising-global-bond-yields-wallet/story?id=136139714) its highest level in nearly two decades...",
    "text": "A key long-term Treasury rate hit its highest level in nearly two decades earlier this month, even before the Federal...",
    "wordCount": 735,
    "fullTextStatus": "ok"
}
```

You can download the dataset in JSON, CSV, Excel, XML, RSS or HTML, or read it through the [Apify API](https://docs.apify.com/api/v2).

### Monitoring news with schedules and integrations

1. Save your input as a **Task**, with *Only new articles* on and a monitor name like `brand-mentions`.
2. Add a **Schedule** (for example, every hour).
3. Connect an **integration** to send new articles to Slack, email, Google Sheets, Zapier, Make, n8n or a webhook.

Each run returns only new articles, so your channel gets no duplicates and you don't pay for repeats.

### Use with AI agents and LLMs

You can call this Actor from AI agents through the [Apify MCP server](https://mcp.apify.com), LangChain, LlamaIndex, CrewAI or plain HTTP. Turn on **Get full article text** to get clean Markdown that fits directly into an LLM context window or a vector database.

### FAQ

**Why do some articles have no full text?**
Some publishers use paywalls (WSJ, FT and others) or block automated access. For those, you still get the headline, real URL and date, `fullTextStatus` explains why, and you're not charged for full text. This scraper does not bypass paywalls.

**Why did I get fewer articles than I asked for?**
Google News only has as many articles as it has indexed for your query and time range. Narrow queries and short time ranges return fewer results. Widen the time range or use broader keywords.

**Can I scrape historical news?**
Yes. Choose *Custom dates* and set `dateFrom` and `dateTo`. The scraper walks through the range window by window.

**Is it legal to scrape Google News?**
This Actor collects publicly available headlines, links and publication dates, and it doesn't collect personal data. Article text belongs to its publishers: make sure your use of it (for example, analysis and research versus republishing) respects copyright and the laws that apply to you. If you're unsure, consult a lawyer. See also Apify's post on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

**Something doesn't work or you need a feature?**
Open an issue in the **Issues** tab. Issues are answered quickly, and feature requests are welcome.

# Actor input Schema

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

What to search for, one query per line. Google News operators work: "exact phrase", OR, -exclude, site:reuters.com, intitle:word.

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

Scrape Google News headline sections instead of (or as well as) searching. These return the current headlines, up to about 70 per topic.

## `region` (type: `string`):

Which Google News edition to use.

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

Only return articles published in this period. Choose "Custom dates" to set exact dates below.

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

Start date (inclusive) when the time range is "Custom dates".

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

End date (inclusive) when the time range is "Custom dates". Leave empty for today.

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

Google News shows at most 100 results per search. Above 100, the scraper automatically splits the time range into smaller windows to collect more (works with Past 7 days, Past 30 days, Past year and Custom dates).

## `decodeUrls` (type: `boolean`):

Replace Google's news.google.com redirect links with the real article URL (for example https://www.reuters.com/...). Recommended.

## `fetchFullText` (type: `boolean`):

Open every article and extract its main text as clean Markdown and plain text, plus author, image and description. Ideal for AI, RAG and sentiment analysis. Charged as an extra event only when the text is extracted successfully; paywalled articles are not charged.

## `excludeSources` (type: `array`):

Skip articles from these publishers. Use a domain (example.com) or the exact source name shown in Google News.

## `dedupeAcrossQueries` (type: `boolean`):

If the same article matches several queries, return it only once (for the first matching query).

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

Remember what earlier runs returned and output only articles you haven't received before. Use with a schedule (for example, every hour) to monitor news and pay only for new articles.

## `monitorKey` (type: `string`):

Runs that share the same monitor name share their memory of already-seen articles. Use a different name for each separate monitor.

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

Usually not needed. Turn on if you run very large jobs and see blocked requests.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "region": "US:en",
  "timeRange": "any",
  "maxItemsPerQuery": 100,
  "decodeUrls": true,
  "fetchFullText": false,
  "dedupeAcrossQueries": true,
  "onlyNew": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `articles` (type: `string`):

One item per news article: headline, publisher, real publisher URL, publication date and, in full text mode, the article text as Markdown and plain text.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kvali/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"] }

# Run the Actor and wait for it to finish
run = client.actor("kvali/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"
  ]
}' |
apify call kvali/google-news-scraper --silent --output-dataset

```

## MCP server setup

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