# Google News Scraper: Search, Topics, Real Publisher URLs (`datagleaner/google-news-scraper`) Actor

Google News scraper and API: search any keyword, topic or feed in any language and country, with every news.google.com link decoded to the publisher's real URL. Title, source, time, image, description, author. $1.50 per 1,000 articles. No login, no API key.

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

## Pricing

$1.50 / 1,000 news 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 and API: search any keyword or topic, with real publisher URLs

**Search Google News by keyword, section or feed URL, in any language and country, and get one row per article: headline, source, publish time, and the publisher's real article URL instead of the news.google.com redirect.** Image, description and author are added from the publisher page where the site provides them. JSON, CSV or Excel. No login, no API key, no browser. **$1.50 per 1,000 articles, URL decoding included.**

#### Why this one

- **Real article links.** Google's links redirect through news.google.com, so a normal crawler cannot open or deduplicate them. Every row carries `articleUrl` (the publisher's page) next to the original `googleNewsUrl`; it works as a Google News URL decoder for a downstream scraper, a database or an LLM pipeline. Decoding is on by default and in the price.
- **You choose how many, and the time window.** `maxArticlesPerQuery` caps each query (and your cost), and `timeframe` filters to the past hour, day, 7 days, 30 days or year. `splitByTime` goes past Google's 100-article feed ceiling, up to 5,000 per search query over the last 90 days.
- **Any language, any country.** Set `language` and `country` (`de`/`DE`, `ja`/`JP`, `zh-TW`/`TW`, `es-419`/`MX`...); Google operators such as `site:reuters.com`, `"exact phrase"` and `OR` work in queries.
- **Search, sections and feed URLs in one run.** Queries, the sections TOP to HEALTH, or any news.google.com URL (converted to its RSS feed).
- **Works from Apify's servers without a proxy.** It reads Google's public RSS feeds over plain HTTP.
- **Honest about metadata.** Description, image and author come from each publisher's page: about a third of publishers block automated requests or set no such tag, so those fields can be `null` while the link and headline are always there.

#### Minimal input

```json
{"queries": ["openai"], "timeframe": "1d", "maxArticlesPerQuery": 20}
```

An empty input runs 5 articles for "artificial intelligence".

#### Sample output row

A real row from a platform run on 2026-10-11 (query `openai`, US edition; `googleNewsUrl` shortened):

```json
{
  "title": "OpenAI to bring in $20 billion less than previously expected",
  "source": "Mashable",
  "sourceUrl": "https://mashable.com",
  "articleUrl": "https://mashable.com/tech/openai-20-billion-less-revenue",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMiZ0FVX3lxTE1wRW5JWTFpTG5WZ0taS...",
  "publishedAt": "2026-10-10T23:40:48Z",
  "publishedTimestamp": 1791675648000,
  "description": "Investors expected more.",
  "imageUrl": "https://helios-i.mashable.com/imagery/articles/03JI1NtsPJWfUM6aQRFzLZM/hero-image.fill.size_1200x675.v1791561333.jpg",
  "author": "Matt Binder",
  "articlePublishedAt": "2026-10-09T18:56:41Z",
  "relatedArticles": [],
  "position": 2,
  "sourceType": "search",
  "query": "openai",
  "topic": null,
  "timeframe": "1d",
  "feedUrl": "https://news.google.com/rss/search?q=openai+when:1d&hl=en-US&gl=US&ceid=US:en",
  "language": "en-US",
  "country": "US",
  "scrapedAt": "2026-10-11T06:10:02Z",
  "input": "openai"
}
```

#### Price

**$1.50 per 1,000 articles** ($0.0015 each), publisher-URL decoding included. 5 queries at 100 articles each is 500 articles = $0.75; 20 queries a day at 100 articles each is $3.00 a day. Set a maximum charge and the run stops when it is reached.

### What does Google News Scraper do?

- Searches Google News by keyword, with Google operators (`"exact phrase"`, `OR`, `-exclude`, `site:reuters.com`, `intitle:`).
- Reads the front page and the standard sections: TOP, WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH.
- Accepts any `news.google.com` URL (search page, `/topics/...` page, RSS link) and converts it to its RSS feed.
- Filters searches by time: past hour, day, 7 days, 30 days or year.
- Works in any language edition (Chinese, Japanese, German, Spanish, Portuguese and more).
- Opens each publisher page (on by default) to add image, description and author from its meta tags. Turn `fetchArticleMeta` off for a faster run with links only.
- Optionally goes past Google's 100-article feed ceiling on search queries with `splitByTime`.

Typical uses: media and brand monitoring, PR and competitor tracking, financial news feeds, news datasets for LLM and RAG pipelines, alerts on a topic, regional news comparison.

### Input

| Field | Type | What it does |
|---|---|---|
| `queries` | list of text | Search queries. Default `["artificial intelligence"]`. Google operators work. |
| `topics` | list of choices | Optional: TOP, WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH. |
| `feedUrls` | list of text | Optional: any news.google.com RSS or page URL. Page URLs are converted to RSS. |
| `language` | text | Interface language `hl`, default `en-US`. |
| `country` | text | Edition country `gl`, default `US`. |
| `timeframe` | choice | `any` (default), `1h`, `1d`, `7d`, `30d`, `1y`. Applied to search queries only, through Google's `when:` operator. |
| `maxArticlesPerQuery` | number | Default and maximum 100 (Google's per-feed ceiling). Also your cost cap per feed. |
| `splitByTime` | yes/no | Default no. Go past 100 articles per search query (see Limits). Search queries only, not topics or feed URLs. |
| `splitMaxArticles` | number | Default 500, range 100 to 5,000. Cap per search query when `splitByTime` is on, and your cost cap per query. |
| `decodeUrls` | yes/no | Default yes. Resolve the publisher URL. |
| `fetchArticleMeta` | yes/no | Default yes. Read image, description, author and published time from the publisher page. Turn off for a faster run with links only. Needs `decodeUrls`. |
| `requestDelaySeconds` | number | Pause before requests, default 0.3. |
| `maxConcurrency` | number | Concurrent decodes, default 5. |
| `proxyConfiguration` | object | Optional Apify Proxy. Default none. |

```json
{
  "queries": ["tesla", "openai OR anthropic"],
  "topics": ["BUSINESS"],
  "language": "en-US",
  "country": "US",
  "timeframe": "1d",
  "maxArticlesPerQuery": 100,
  "decodeUrls": true,
  "fetchArticleMeta": true
}
```

#### Language and country

`language` and `country` choose the Google News edition. The Actor derives the `ceid` value Google expects, so you only set the two fields:

| Edition | language | country | ceid used |
|---|---|---|---|
| United States | `en-US` | `US` | `US:en` |
| United Kingdom | `en-GB` | `GB` | `GB:en` |
| Taiwan (Traditional Chinese) | `zh-TW` | `TW` | `TW:zh-Hant` |
| China (Simplified Chinese) | `zh-CN` | `CN` | `CN:zh-Hans` |
| Japan | `ja` | `JP` | `JP:ja` |
| Germany | `de` | `DE` | `DE:de` |
| France | `fr` | `FR` | `FR:fr` |
| Mexico (Latin American Spanish) | `es-419` | `MX` | `MX:es-419` |
| Brazil | `pt-BR` | `BR` | `BR:pt-BR` |
| South Korea | `ko` | `KR` | `KR:ko` |

Other combinations follow the same pattern. If a feed URL you pass already has `hl`, `gl` and `ceid`, those are kept.

### Output

One row per article. A shortened example:

```json
{
  "title": "Woman Spots Tesla In New Jersey. Then It Almost Goes Off A Cliff",
  "source": "Motor1.com",
  "sourceUrl": "https://www.motor1.com",
  "articleUrl": "https://www.motor1.com/news/810717/tesla-drives-off-cliff/",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMiakFVX3lx...?oc=5",
  "publishedAt": "2026-10-09T07:38:04Z",
  "publishedTimestamp": 1791531484000,
  "description": null,
  "imageUrl": null,
  "author": null,
  "articlePublishedAt": null,
  "relatedArticles": [],
  "position": 1,
  "sourceType": "search",
  "query": "tesla",
  "topic": null,
  "timeframe": "1d",
  "feedUrl": "https://news.google.com/rss/search?q=tesla+when:1d&hl=en-US&gl=US&ceid=US:en",
  "language": "en-US",
  "country": "US",
  "scrapedAt": "2026-10-09T09:43:30Z",
  "input": "tesla"
}
```

What to expect in each field:

- `articleUrl` is the publisher's URL. If Google refuses to decode one link, the row is still returned with `articleUrl` empty and `googleNewsUrl` set; the run does not fail.
- `publishedTimestamp` is `publishedAt` as Unix time in milliseconds.
- `sourceType` says which input produced the row (`search`, `topic` or `feedUrl`). `timeframe` is the time range applied to a search row, null otherwise.
- `relatedArticles` is filled only on some topic and front-page feeds, where Google groups several outlets under one story (list of `title`, `source`, `googleNewsUrl`). It is empty on search feeds and often on topic feeds too; do not rely on it.
- `description` is empty in Google's own search feed, which only repeats the headline. With `fetchArticleMeta` on (the default) the Actor fills `description`, `imageUrl`, `author` and `articlePublishedAt` from the publisher page. These are not guaranteed for every row: about a third of publishers refuse automated requests (HTTP 403) or set no such tag, and those fields stay null. With `fetchArticleMeta` off, `author` and `articlePublishedAt` are always empty, and `description` and `imageUrl` hold only what Google's feed carries, which is usually nothing.
- `position` is the rank of the article inside its feed. Articles are deduplicated across the whole run; the first occurrence wins.

Empty input runs a built-in example: 5 articles for "artificial intelligence". The input prefill does the same search with the usual 100-article limit.

### Pricing

Pay per event: **$1.50 per 1,000 articles** ($0.0015 per article), charged for each article row written to the dataset. Platform usage is included in that price; you pay nothing else for this Actor.

Worked example: 5 queries at 100 articles each is 500 articles, so 500 x $0.0015 = **$0.75**. A daily run of 20 queries at 100 articles each is 2,000 articles = $3.00 per day.

Set a maximum total charge on the run and the Actor stops cleanly when it is reached; everything collected up to that point is kept.

### Limits

- **About 100 articles per feed.** Google News returns at most about 100 items for one query and about 70 for a topic, with no paging.
- **More than 100 per search query: `splitByTime`.** Turn it on and each search query is asked again over day windows (Google's `after:`/`before:`), newest first, and any window that comes back full is split further. It stops at `splitMaxArticles` (default 500, up to 5,000 per query). It affects search queries only, not topics or feed URLs, and is off by default. Google ranks a feed by relevance, not date, so this is not a full history: without a `timeframe` it covers the last 90 days, with one it covers that range, and older articles are not reached. Splitting adds billable items, so `splitMaxArticles` is also your cost cap per query. Other ways to widen a search: `when:` ranges in the query, `site:` operators or different wording. The Actor removes duplicates across the whole run.
- **Recency, not an archive.** Google News feeds show recent coverage. `timeframe: 1y` is the furthest back the filter goes.
- **Decoding costs two extra requests per article** and the Google News article page is about 590 KB, so a run of 100 articles with `decodeUrls` on takes around 30 seconds before `fetchArticleMeta` adds one publisher-page request per article. Turn `decodeUrls` off if the `googleNewsUrl` is enough.
- **Publisher pages (`fetchArticleMeta`)** are fetched once with a short timeout. Paywalled or bot-protected sites leave the fields empty.
- Google may change its feeds or its link format. If decoding starts failing, rows still come back with `articleUrl` empty.

### Use with Python

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datagleaner/google-news-scraper").call(
    run_input={"queries": ["openai"], "timeframe": "1d", "maxArticlesPerQuery": 10}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["publishedAt"], item["source"], item["title"])
    print("   ", item["articleUrl"])
```

This run returns at most 10 articles, so it costs at most $0.015.

### Use with JavaScript / Node.js

```js
// npm install apify-client
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/google-news-scraper').call({
    queries: ['openai'],
    timeframe: '1d',
    maxArticlesPerQuery: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const a of items) console.log(a.publishedAt, a.source, a.title, a.articleUrl);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/google-news-scraper`

Minimal input:

```
{"queries": ["openai"], "timeframe": "1d", "maxArticlesPerQuery": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/google-news-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/google-news-scraper`. Without a token, an agent can still find the Actor with the `search-actors` tool, but running it needs your Apify account. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/google-news-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Or pass a token instead:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/google-news-scraper" --header "Authorization: Bearer YOUR_APIFY_TOKEN"
  ```

  Claude Desktop, Cursor and other clients that use an `mcpServers` config can run the server locally:

  ```
    {
      "mcpServers": {
        "actors-mcp-server": {
          "command": "npx",
          "args": ["-y", "@apify/actors-mcp-server"],
          "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
        }
      }
    }
  ```

  Then ask in plain language, for example: "Use the Google News scraper to get the past day's news about TSMC from the US edition and about 台積電 from the Taiwan edition, 30 articles each, and give me a table of headline, outlet, time and the publisher's link."
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/google-news-scraper")
result = tool.invoke({"run_input": json.loads('{"queries": ["openai"], "timeframe": "1d", "maxArticlesPerQuery": 10}')})
```

### FAQ

**Is this a Google News API?** It works as one: send queries, topics or feed URLs through the Apify API, the clients above or MCP, and get JSON back. It needs no Google account or Google API key, only an Apify account.

**How do I decode Google News RSS URLs?** Leave `decodeUrls` on (the default). Each row then carries the publisher's link in `articleUrl` next to the original `googleNewsUrl`. If Google refuses one link after retries, `articleUrl` stays empty and the row is still returned.

**Can I scrape Google News without a proxy?** Yes. It worked from Apify datacenter IPs without one. The `proxyConfiguration` field is there if you want to route traffic through one.

**How do I get news in another language or country?** Set `language` and `country`, for example `zh-TW` and `TW`, or `ja` and `JP`. Write the query in that language to get matching results.

**Can I search one site or get more than 100 articles?** Use `site:reuters.com tesla` as a query. Each feed stops at about 100 articles; turn on `splitByTime` to get up to `splitMaxArticles` (default 500, maximum 5,000) per search query over the last 90 days or your `timeframe`. Duplicates are removed across the run.

### Responsible use

This Actor collects only publicly available Google News feed data and fetches publicly available publisher pages; it does not log in, solve CAPTCHAs or bypass blocks. Google's feed terms limit RSS use to personal, non-commercial feed reading, so check that your use is permitted. Article text and images belong to their publishers: the Actor returns links and metadata, not full articles, and you are responsible for respecting copyright and each publisher's terms. If the data you collect includes personal data (for example author names), you are responsible for handling it lawfully, including under GDPR where it applies.

# Actor input Schema

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

What to search Google News for. Google operators work: "exact phrase", OR, -exclude, site:reuters.com, intitle:word. Each query is one feed of at most 100 articles.

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

Optional. Google News front page (TOP) and section feeds. Each topic is one feed.

## `feedUrls` (type: `array`):

Optional. Any news.google.com RSS or page URL, for example a /topics/... or /search?q=... page, or a publication or story link. Page URLs are converted to their RSS feed.

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

Google News interface language (hl). Common pairs with Country: en-US + US, en-GB + GB, en-IN + IN, zh-TW + TW, zh-CN + CN, ja + JP, ko + KR, de + DE, fr + FR, es-419 + MX, pt-BR + BR. A pair Google does not serve returns no articles, and the status message says so.

## `country` (type: `string`):

Edition country (gl), two letters. Examples: US, GB, TW, JP, DE, FR, MX, BR, KR. The matching ceid value (for example TW:zh-Hant) is derived for you.

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

Adds Google's when: operator to every search query. Does not apply to topics or feed URLs.

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

Google returns at most about 100 articles per feed, so 100 is the ceiling. To get more on a search query, turn on 'Go past 100 articles per query'. Each pushed article is billed, so this is also your cost cap per feed.

## `splitByTime` (type: `boolean`):

Google caps a feed at about 100 articles. When on, each search query is asked again over day windows (Google's after:/before:), newest first, covering the last 90 days or your time range, and any window that comes back full is split further. Stops at the cap below. Search queries only. Every article is billed once; repeats are dropped.

## `splitMaxArticles` (type: `integer`):

Cap per search query when 'Go past 100 articles per query' is on. Also your cost cap per query.

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

Resolve each news.google.com link to the publisher's real article URL (2 extra requests per article). If an item cannot be decoded it is still returned, with articleUrl empty.

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

Open each publisher page and read its image (og:image), description, author and published time from the meta tags and JSON-LD. On by default. Fields stay empty where the publisher blocks the request or has no such tag. Turn it off for a faster run with links only. Needs Decode publisher URLs.

## `requestDelaySeconds` (type: `number`):

Pause before requests, randomised up to 1.5x.

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

How many articles are decoded at the same time. Lower it if you see rate-limit retries in the log.

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

Optional Apify Proxy. Default is no proxy; Google News answered from Apify datacenter IPs without one.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "language": "en-US",
  "country": "US",
  "timeframe": "any",
  "maxArticlesPerQuery": 30,
  "splitByTime": false,
  "splitMaxArticles": 500,
  "decodeUrls": true,
  "fetchArticleMeta": true,
  "requestDelaySeconds": 0.3,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

No description

## `results` (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 = {
    "queries": [
        "artificial intelligence"
    ],
    "maxArticlesPerQuery": 30
};

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

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

```

## MCP server setup

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