# Google News Scraper API: Articles, Real URLs, Full Text (`actose/google-news-rss`) Actor

Google News articles by keyword, site or topic in 60+ countries: title, source, date, real publisher URL, full text, Markdown for LLMs. Dedup and only-new mode. Google News API alternative. No API key, no login. MCP-ready for AI agents. Pay per result, errors are free. $4 per 1,000 articles.

- **URL**: https://apify.com/actose/google-news-rss.md
- **Developed by:** [ABM](https://apify.com/actose) (community)
- **Categories:** News, SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 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 API: Articles, Real URLs, Full Text

**$4 per 1,000 articles** · pay per result, no monthly rental · errors, duplicates and empty results are free · no API key, no login

Scrape **Google News** by **keyword, website or topic** in **60+ countries and languages**. You get clean JSON with the headline, publisher, publication date, the **real publisher URL (not the news.google.com redirect)**, related coverage, LLM-ready **Markdown**, and (optionally) the **full article text** split into chunks for RAG. Results are deduplicated across queries and countries, and **Only new** mode returns only the articles you have not received yet, which suits scheduled monitoring.

It is a **Google News API alternative**: Google has no public Google News API, so this actor reads the official Google News RSS feeds over plain HTTP. No browser and no account are needed, so it is fast, light and stable.

### How much does it cost?

| Event | Price | When it is charged |
|---|---|---|
| `article` | **$0.004** ($4 / 1,000) | One unique article delivered with its resolved publisher URL |
| `article-text` | $0.001 ($1 / 1,000) | Only if you enable *Extract full article text* **and** text was actually extracted |

**Example:** 1,000 articles = **$4.00**. 1,000 articles with full text = $5.00. A daily brand watch with 50 new articles a day costs about $6 a month.

**Never charged:** duplicates, articles already delivered (with *Only new*), articles whose Google link could not be resolved (they are still returned with `urlResolved: false`), failed or blocked feeds, empty searches, and paywalled or empty pages for the text option. To cap your spend, use **Max articles in total** or the run's maximum cost. The actor stops cleanly when your budget is reached.

### What it does

- **Keyword search** with every Google operator: `"exact phrase"`, `OR`, `-exclude`, `intitle:`, `site:`, `when:7d`.
- **Site monitoring**: the latest articles from the domains you list (`lemonde.fr`, `reuters.com`…).
- **Topics**: Top stories, World, Nation, Business, Technology, Entertainment, Sports, Science, Health, or any topic/entity ID from news.google.com.
- **Several countries and languages**: `US`, `FR`, `DE`, `JP`, `BR`… The language is picked automatically for each edition, or you can force it with `CA:fr`, `US:es`, `BE:nl`.
- **Time filters**: past hour, day, week, month or year, or an exact date range.
- **More than 100 results per query**: Google caps each feed at 100 items. *Split by day* runs one search per day of your date range.
- **Real URLs**: Google's encrypted redirect links are converted to the publisher URL.
- **Deduplication** by Google ID, by title + source, and by final URL without tracking parameters (`utm_*`, `fbclid`…). `matchedQueries` and `matchedEditions` list every query and country where the article appeared.
- **Only new** (`onlyNew`): for scheduled runs, articles delivered by previous runs are skipped and not charged.
- **LLM-ready output**: every item has a `markdown` field. With full text on, `textChunks` (set with `ragChunkSize`) gives paragraph-aligned chunks ready for embeddings.
- **Full text (optional)**: the main text, author, main image and description from the publisher page.

### Input example

```json
{
  "keywords": ["artificial intelligence", "\"electric vehicles\" -tesla"],
  "sites": ["reuters.com"],
  "topics": ["TECHNOLOGY"],
  "countries": ["US", "FR", "DE", "CA:fr"],
  "timeRange": "7d",
  "maxArticlesPerQuery": 50,
  "maxArticles": 500,
  "resolveUrls": true,
  "deduplicate": true,
  "extractText": false
}
```

Scheduled monitoring (run every hour; you only get and pay for new articles):

```json
{
  "keywords": ["\"Acme Corp\"", "Acme CEO"],
  "countries": ["US", "GB", "FR"],
  "timeRange": "1d",
  "onlyNew": true,
  "extractText": true,
  "ragChunkSize": 1500
}
```

Date range, day by day (collect thousands of articles for a period):

```json
{
  "keywords": ["inflation"],
  "countries": ["US"],
  "dateFrom": "2026-09-01",
  "dateTo": "2026-10-01",
  "splitByDay": true,
  "maxArticlesPerQuery": 3000,
  "maxArticles": 3000
}
```

### Output example

One dataset item per unique article:

```json
{
  "title": "Bitcoin: BloFin sees bullish signals despite the recent correction",
  "source": "Cointribune",
  "sourceUrl": "https://www.cointribune.com",
  "url": "https://www.cointribune.com/en/bitcoin-blofin-bullish-signals/",
  "urlResolved": true,
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMiowFBVV95cUxP...?oc=5",
  "guid": "CBMiowFBVV95cUxP...",
  "publishedAt": "2026-10-11T07:00:00Z",
  "query": "bitcoin",
  "queryType": "keyword",
  "country": "FR",
  "language": "fr",
  "edition": "FR:fr",
  "timeWindow": "7d",
  "matchedQueries": ["bitcoin", "crypto"],
  "matchedEditions": ["FR:fr", "BE:fr"],
  "relatedArticles": [],
  "markdown": "## Bitcoin: BloFin sees bullish signals despite the recent correction\n\nCointribune · 2026-10-11T07:00:00Z · FR:fr\n\nhttps://www.cointribune.com/en/bitcoin-blofin-bullish-signals/",
  "feedUrl": "https://news.google.com/rss/search?q=bitcoin%20when%3A7d&hl=fr&gl=FR&ceid=FR%3Afr",
  "scrapedAt": "2026-10-15T08:12:44Z"
}
```

With *Extract full article text* turned on, these fields are added (`textChunks` only when `ragChunkSize` > 0), and `markdown` then includes the text:

```json
{
  "text": "Bitcoin is trading below its recent high after...",
  "textLength": 3812,
  "textChunks": ["Bitcoin is trading below its recent high after...", "Analysts expect..."],
  "author": "Jane Doe",
  "imageUrl": "https://www.cointribune.com/app/uploads/2026/10/btc.jpg",
  "articleDescription": "Analysts at BloFin point to...",
  "siteName": "Cointribune",
  "textError": null
}
```

Topic feeds (Top stories, Business…) also fill `relatedArticles` with the other headlines in the same story cluster (`title`, `source`, `googleNewsUrl`). A run summary (delivered, unresolved, duplicates, already seen, proxy traffic) is saved in the key-value store as `SUMMARY`.

### Use with AI agents (MCP)

This actor is MCP-ready. Add it to **Claude, Cursor, ChatGPT** or any MCP client through the Apify MCP server (`https://mcp.apify.com`) and your agent can call it as a tool, for example: *"Get today's news about Nvidia in the US and Germany and summarize it"*. The `markdown` field can go straight into a prompt. `textChunks` is ready for vector databases (RAG). Because each article is billed separately, an agent only pays for what it actually reads.

### Integrations

- **API**: run it from any language with the Apify API or the Python/JavaScript clients, and get results as JSON, CSV, Excel or XML.
- **Make, Zapier, n8n**: use the official Apify modules/nodes to send new articles to Slack, email, Notion or a CRM.
- **Google Sheets**: export the dataset, or use the Apify integration to append new articles to a sheet on every scheduled run.
- **Webhooks and schedules**: run it every hour with `onlyNew: true` and get a webhook when new articles arrive.

### Use cases

- **Media monitoring and PR**: track a brand, product or executive across countries every hour.
- **Market and competitive intelligence**: follow the news flow on companies, sectors and tickers.
- **AI agents and RAG**: feed fresh, deduplicated articles (with full text) to an LLM for summaries, alerts or sentiment.
- **SEO and content**: see which publishers rank in Google News for your keywords, in each country.
- **Research and datasets**: build historical news corpora with day-by-day date ranges.

### FAQ

**Is there an official Google News API?** No. Google shut down its News API years ago. This actor gives you the same data in a structured form, with no API key and no quota.

**Why do I need the "real URL"?** Google News links point to `news.google.com/rss/articles/...`, which you can't use for analytics, deduplication or text extraction. This actor returns the publisher URL in `url`.

**How many results can I get?** Up to 100 per query, per country, per feed. That is Google's limit. To go beyond it, use several keywords, several countries, or *Split by day* with a date range.

**How does "Only new" work?** The IDs and URLs of the articles you received are stored in your own named key-value store `google-news-rss-state`, with one history per search configuration (or the name you set in `stateKey`). Later runs skip those articles and are not charged for them.

**How do I choose a language?** By default each country uses the language of its Google News edition (US → English, FR → French, BR → Portuguese…). Write `COUNTRY:language` to force another one, e.g. `CA:fr`, `US:es`, `IN:hi`.

**Does it use a browser or log in?** No. It only reads public RSS feeds and public pages over plain HTTP.

**Do I need a proxy?** The default Apify datacenter proxy is enough. A residential IP is used only as a fallback when Google rate-limits a link resolution. It handles a few kilobytes per link, under a traffic cap you control.

### Limits

- Google returns at most 100 items per feed, and publication dates are the ones Google reports.
- Very old articles may not be available through date-range searches.
- Link resolution depends on an internal Google endpoint. If Google changes it, articles are still returned with `urlResolved: false` and are **not charged** until it is fixed. The run status says so.
- Full-text extraction cannot read paywalled, JavaScript-only or video pages. In that case `textError` explains why and no text event is charged.
- Search operators and time filters work the way Google applies them, which is best effort on Google's side.

# Actor input Schema

## `keywords` (type: `array`):

One Google News search per line. Google search operators work: "exact phrase", OR, -exclude, intitle:, site:, when:7d. Example: tesla site:reuters.com

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

Get the latest Google News articles from these publishers (runs a site:domain search). Example: lemonde.fr, bbc.co.uk

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

Google News sections. TOP = the front page (top stories) of each country. If you give no keyword, site or topic, TOP is used.

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

Any Google News topic or entity page: copy the ID after /topics/ in a news.google.com URL (starts with CAAq...).

## `countries` (type: `array`):

Two-letter country codes, e.g. US, GB, FR, DE, IN, BR, JP. The language of each country's edition is chosen automatically. To force a language use COUNTRY:language, e.g. CA:fr, US:es, BE:nl, CH:fr.

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

Force one language for all countries without an explicit COUNTRY:language, e.g. en. Leave empty to use each country's own language.

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

Only keep articles published within this period (keyword and site searches only). Ignored when a date range is set.

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

Only articles published on or after this date (YYYY-MM-DD). Keyword and site searches only.

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

Only articles published before this date (YYYY-MM-DD, exclusive).

## `splitByDay` (type: `boolean`):

Google News returns at most 100 articles per feed. With a From date, this runs one search per day so you can collect thousands of articles for a period (max 400 days).

## `maxArticlesPerQuery` (type: `integer`):

Limit per keyword/site/topic and per country. One feed gives up to 100 articles (more with Split by day).

## `maxArticles` (type: `integer`):

Hard cap on the number of billed articles for the whole run.

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

Turn news.google.com redirect links into the publisher URL. Articles that cannot be resolved are still returned but are not billed. Disable for maximum speed (url will then be empty for most articles).

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

Merge the same article found by several queries or countries (by Google ID, title + source, and final URL without tracking parameters). Duplicates are never billed.

## `extractText` (type: `boolean`):

Download each publisher page and extract the main text, author, image and description. Billed as an extra 'article-text' event only when text is actually extracted (paywalls and video pages are not billed).

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

Skip articles already delivered by previous runs with the same search (same keywords, sites, topics and countries). The history is kept in your named key-value store 'google-news-rss-state'. Skipped articles are not charged. Perfect for hourly or daily monitoring.

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

Give the 'Only new' history a fixed name (e.g. brand-monitoring) so you can change the search and keep the history, or share it between tasks. Leave empty: one history per search configuration.

## `ragChunkSize` (type: `integer`):

With 'Extract full article text', also return textChunks: the text cut on paragraph boundaries into chunks of about this many characters, ready for embeddings. 0 = off. Every item always has a 'markdown' field (title, source, date, URL and text) ready for LLMs.

## `maxConcurrency` (type: `integer`):

How many articles are processed in parallel. Higher is faster but more likely to be rate-limited by Google.

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

Datacenter proxy (default) is enough for Google News RSS.

## `residentialFallback` (type: `boolean`):

If Google rate-limits the datacenter IPs while resolving links, retry the blocked request once through a residential IP. Only tiny Google pages go through it.

## `maxResidentialMb` (type: `integer`):

Stop using the residential fallback after this much traffic in one run.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence",
    "electric vehicles"
  ],
  "sites": [],
  "topics": [],
  "topicIds": [],
  "countries": [
    "US",
    "FR",
    "DE"
  ],
  "timeRange": "7d",
  "splitByDay": false,
  "maxArticlesPerQuery": 20,
  "maxArticles": 100,
  "resolveUrls": true,
  "deduplicate": true,
  "extractText": false,
  "onlyNew": false,
  "ragChunkSize": 0,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true,
  "maxResidentialMb": 100
}
```

# Actor output Schema

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

One item per unique news article

## `articlesFull` (type: `string`):

No description

## `summary` (type: `string`):

Counts of delivered, unresolved and duplicate articles, proxy traffic

# 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 = {
    "keywords": [
        "artificial intelligence",
        "electric vehicles"
    ],
    "sites": [],
    "topics": [],
    "topicIds": [],
    "countries": [
        "US",
        "FR",
        "DE"
    ],
    "timeRange": "7d",
    "maxArticlesPerQuery": 20,
    "maxArticles": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("actose/google-news-rss").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 = {
    "keywords": [
        "artificial intelligence",
        "electric vehicles",
    ],
    "sites": [],
    "topics": [],
    "topicIds": [],
    "countries": [
        "US",
        "FR",
        "DE",
    ],
    "timeRange": "7d",
    "maxArticlesPerQuery": 20,
    "maxArticles": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("actose/google-news-rss").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 '{
  "keywords": [
    "artificial intelligence",
    "electric vehicles"
  ],
  "sites": [],
  "topics": [],
  "topicIds": [],
  "countries": [
    "US",
    "FR",
    "DE"
  ],
  "timeRange": "7d",
  "maxArticlesPerQuery": 20,
  "maxArticles": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call actose/google-news-rss --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,actose/google-news-rss"
        }
    }
}
```

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/1krale8GBXaKI0qJ6/builds/V3mKVgReGYfx2Knjk/openapi.json