# Google News Scraper - Search, Topics & Headlines (`solidscrape/google-news-scraper`) Actor

Scrape Google News without an API key: search queries, topic/geo headlines, and top stories. Optionally resolve real publisher URLs and extract article text. Export JSON/CSV/Excel.

- **URL**: https://apify.com/solidscrape/google-news-scraper.md
- **Developed by:** [Shahryar](https://apify.com/solidscrape) (community)
- **Categories:** News, Marketing
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google News Scraper – Search, Topics, Headlines & Article Text (No API Key)

The **Google News scraper** collects news headlines from **Google News** without an API key or login: run **search queries**, pull **topic** and **geo** headline feeds, and grab the front-page **top stories** — in any language/country edition. Optionally **resolve the real publisher URL** behind each Google News redirect and **extract the full article text**, author, and publish date. Use it as a **Google News API** alternative and **export to JSON, CSV, or Excel**.

Built for **media monitoring, brand and PR tracking, SEO and content research, and news aggregation** — a fast Google News data extractor that turns public RSS feeds into clean, structured records.

> **Pairs with the [Hacker News Scraper](https://apify.com/store)** for full news + tech-community monitoring in one pipeline.

### Why this scraper

Google News exposes clean RSS feeds, but two things make them awkward to use directly: every link is a `news.google.com` redirect (not the publisher), and the feeds are point-in-time snapshots with **no pagination**. This Actor parses the feeds into structured records, optionally **resolves the redirect to the real publisher URL** via Google's current 2-step `batchexecute` flow, and lets you broaden coverage by splitting queries with Google News operators (`when:`, `site:`, date ranges). It only claims what it does — resolution and article-text extraction are **best-effort** and never fail the run.

### What it does

- 🔎 **Search feeds** – each query becomes a `/rss/search?q=` feed. Supports Google News operators: `when:7d`, `site:reuters.com`, `intitle:ai`, `before:/after:` dates, boolean `OR`, exact `"quotes"`, and `-exclusions`.
- 🗂️ **Topic feeds** – WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH.
- 📍 **Geo feeds** – place-based headlines, e.g. `London`, `San Francisco`.
- 🏠 **Top stories** – the front-page feed for the chosen edition.
- 🌍 **Any edition** – `language` + `country` drive `hl`, `gl`, and the matching `ceid`.
- 🔗 **Real publisher URLs (optional)** – resolve each `news.google.com` redirect to the actual article URL (best-effort).
- 📝 **Article text (optional)** – fetch the resolved page and extract main body text, author, and published date (best-effort; publishers vary).

### Example input

```json
{
  "queries": ["artificial intelligence", "tesla when:7d", "site:reuters.com climate"],
  "topics": ["TECHNOLOGY", "BUSINESS"],
  "geoLocations": ["London"],
  "includeTopStories": false,
  "language": "en-US",
  "country": "US",
  "maxItemsPerQuery": 100,
  "maxItems": 1000,
  "resolveArticleUrls": false,
  "scrapeArticleText": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Example output (article)

```json
{
  "type": "article",
  "title": "OpenAI announces new model",
  "link": "https://news.google.com/rss/articles/CBMi…?oc=5",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMi…?oc=5",
  "guid": "CBMi…",
  "articleId": "CBMi…",
  "source": "Reuters",
  "sourceUrl": "https://www.reuters.com",
  "publishedAt": "2026-06-17T22:55:21.000Z",
  "pubDate": "Wed, 17 Jun 2026 22:55:21 GMT",
  "snippet": "OpenAI announced … Reuters",
  "query": "artificial intelligence",
  "feedType": "search",
  "language": "en-US",
  "country": "US",
  "scrapedAt": "2026-06-20T10:00:00.000Z"
}
```

### Example output (with `resolveArticleUrls` + `scrapeArticleText`)

When those options are enabled, `link` becomes the real publisher URL (when resolution succeeds) and extra fields are added:

```json
{
  "type": "article",
  "title": "OpenAI announces new model",
  "link": "https://www.reuters.com/technology/openai-…",
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMi…?oc=5",
  "source": "Reuters",
  "publishedAt": "2026-06-17T22:55:21.000Z",
  "articleResolved": true,
  "articleText": "OpenAI on Wednesday announced …\n\n…",
  "articleAuthor": "Jane Doe",
  "articlePublishedAt": "2026-06-17T22:50:00.000Z",
  "feedType": "search",
  "language": "en-US",
  "country": "US"
}
```

### Output fields

Every item is pushed with `type: "article"`. The fields below are exactly what the code emits — nothing more, nothing less.

| Field | Type | Description |
|---|---|---|
| `type` | string | Always `"article"` (the only output item type). |
| `title` | string | Headline text. |
| `link` | string | Real publisher URL when `resolveArticleUrls` succeeds, otherwise the Google News redirect. |
| `googleNewsUrl` | string | Always the original `news.google.com` redirect. |
| `guid` | string | The article GUID (CBMi id, `isPermaLink="false"`). |
| `articleId` | string | The CBMi article id extracted from the guid/link. |
| `source` | string | Publisher display name (from `<source>`). |
| `sourceUrl` | string | Publisher homepage (from the `<source url="…">` attribute). |
| `publishedAt` | string | Publish time as ISO 8601 (parsed from RFC-822 `<pubDate>`); `null` if unparseable. |
| `pubDate` | string | Raw `<pubDate>` string. |
| `snippet` | string | Plain-text snippet stripped from the `<description>` HTML. |
| `query` | string | Originating query / topic / place (`null` for top stories). |
| `feedType` | string | `search`, `topic`, `geo`, or `top`. |
| `language` | string | Language used for the feed. |
| `country` | string | Country used for the feed. |
| `scrapedAt` | string | ISO 8601 timestamp of when the item was collected. |

**Extra fields when `resolveArticleUrls` is enabled**

| Field | Type | Description |
|---|---|---|
| `articleResolved` | boolean | Whether the redirect was resolved to a real publisher URL. `false` when resolution failed (the item then keeps the Google News redirect in `link`). |

**Extra fields when `scrapeArticleText` is enabled** (implies `resolveArticleUrls`)

| Field | Type | Description |
|---|---|---|
| `articleText` | string | Extracted main body text (`null` if extraction failed, paywalled, or under the ~80-char threshold). |
| `articleAuthor` | string | Author from the publisher page meta tags / byline (best-effort; `null` if not found). |
| `articlePublishedAt` | string | Published date from the publisher page meta (ISO 8601 when parseable, else the raw meta string; `null` if not found). |

### Input reference

| Field | Type | Description |
|---|---|---|
| `queries` | array | Free-text search queries; each becomes a `/rss/search?q=` feed. Supports Google News operators. |
| `topics` | array (enum) | Topic feeds: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH. |
| `geoLocations` | array | Place names for geo headline feeds, e.g. `London`. |
| `includeTopStories` | boolean | Also fetch the front-page Top stories feed. Default `false`. |
| `language` | string | Interface/content language (`hl`), e.g. `en-US`. Default `en-US`. |
| `country` | string | Edition country (`gl`), e.g. `US`. Default `US`. |
| `maxItemsPerQuery` | integer | Cap items taken from each feed (`0` = no cap). Default `100`. |
| `maxItems` | integer | Global cap on total articles (`0` = no limit). Default `1000`. |
| `resolveArticleUrls` | boolean | Resolve each redirect to the real publisher URL. Default `false`. |
| `scrapeArticleText` | boolean | Fetch the resolved page and extract text/author/date (requires resolve). Default `false`. |
| `proxyConfiguration` | object | Apify proxy settings. Default `useApifyProxy: true`. |

### Common use cases

- **Media & brand monitoring** – track Google News mentions of a company, product, or person with `"brand"` queries and `when:` time windows; export the dataset to CSV/Excel for reporting.
- **PR & competitor tracking** – follow `site:` and topic feeds to see who is covering what across publishers and countries.
- **SEO & content research / news aggregation** – pull topic/geo headlines for a daily digest, newsletter, or content calendar without a Google News API key.
- **Dataset building & NLP** – resolve real publisher URLs and extract full article text, author, and publish date for downstream sentiment analysis, summarization, or model training.
- **Market & finance signals** – monitor ticker, sector, or policy queries in near real time and feed the JSON output into dashboards or alerts.

### Notes & limits

- **No pagination.** Google News feeds are point-in-time snapshots: search feeds return up to ~100 items and topic/geo feeds up to ~30. `maxItemsPerQuery` only **trims** a feed — to get more coverage, split a query with `when:` / `site:` / `before:`/`after:` operators rather than expecting more items per query.
- **Redirect resolution is best-effort.** Current article ids are the long `CBMi…` form whose publisher URL is **not** decodable offline; resolution uses Google's 2-step `batchexecute` flow, which Google changes periodically. On failure the item keeps the Google News redirect and `articleResolved` is `false`.
- **Article-text extraction is best-effort.** Publisher pages vary; some paywall, 403, or show consent walls, so `articleText` can be empty for some items. A single publisher failure never fails the run.
- **Resolution/text add cost & blocking risk.** They issue 1–2 extra requests per item against Google's heavier app surface and arbitrary publisher sites, which throttle sooner than the RSS feeds. The Actor caps concurrency and rotates sessions; use **residential** proxies for large runs.
- **ceid must match the locale.** It is built automatically as `{COUNTRY}:{language-base}` (e.g. `en-US` + `US` → `US:en`); a mismatch returns empty or wrong-locale results.
- **Exotic locales.** Friendly topic names (TECHNOLOGY, …) are verified for `en-US` and major editions; some unusual locales use opaque base64 topic ids — you can pass such an id directly in `topics`.

### FAQ

**Do I need a Google News API key or login?** No. The Actor reads public Google News RSS feeds — there is no API key, OAuth, or login involved. It is a key-free Google News API alternative.

**Why is `link` a `news.google.com` URL?** That is the feed's redirect. Enable `resolveArticleUrls` to turn it into the real publisher URL (best-effort). The original redirect is always preserved in `googleNewsUrl`.

**Why did I only get ~100 results for my query?** Google News search feeds cap at roughly 100 items and topic/geo feeds at ~30, with **no pagination** — they are point-in-time snapshots. Split the query with operators like `when:7d`, `before:`/`after:` date ranges, or `site:` to cover more, or schedule the run to collect over time.

**Can I scrape Google News for any country or language?** Yes. Set `language` (e.g. `en-US`, `en-GB`, `es-419`, `fr`) and `country` (e.g. `US`, `GB`, `IN`, `DE`). They drive `hl`, `gl`, and the `ceid` parameter, which is built automatically as `{COUNTRY}:{language-base}` (so `en-US` + `US` → `ceid=US:en`). A mismatch returns empty or wrong-locale results.

**How do I control how many articles I get?** Use `maxItemsPerQuery` to cap items taken from each feed (trims the snapshot; `0` = no cap) and `maxItems` for a global cap across all feeds (`0` = no limit). Defaults are 100 per feed and 1000 total.

**Which proxy should I use?** Datacenter (the default `useApifyProxy: true`) is fine for the RSS feeds. Switch to **residential** if you enable resolution/article-text at volume and start hitting blocks — those features add 1–2 heavier requests per item against Google's app surface and publisher sites.

**Why is `articleText` empty for some items?** The publisher paywalled, returned 403, showed a consent wall, or rendered the body with JavaScript. Extraction is best-effort, uses meta tags + common article containers, and intentionally never fails the run.

**Can I export the results to JSON, CSV, or Excel?** Yes. Every run's dataset can be exported to **JSON, CSV, Excel (XLSX), HTML, RSS, or XML**, or pulled via the Apify API/SDK and webhooks for downstream pipelines.

**Does this work with topics and geographic (place) feeds, not just search?** Yes. Provide any combination of `queries` (search), `topics` (WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH), `geoLocations` (place names), and `includeTopStories` (front-page feed). Each becomes its own RSS feed.

**Can I monitor news continuously?** Yes. Schedule the Actor (e.g. hourly/daily) to build a rolling dataset for media monitoring or brand tracking. Pair it with the [Hacker News Scraper](https://apify.com/store) to cover both mainstream news and the tech community in one workflow.

# Actor input Schema

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

Free-text queries to run against Google News search. Each becomes its own RSS feed. Supports Google News operators inside a query: time windows ("tesla when:7d"), site filters ("site:reuters.com"), title match ("intitle:ai"), date ranges ("before:2026-01-01 after:2025-12-01"), boolean OR, exact "quotes", and -exclusions.

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

Google News topic headline feeds. Each becomes its own RSS feed. Allowed values: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH. (Topic feeds return ~30 items.)

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

Place-based headline feeds, e.g. "London", "New York", "California". Each becomes its own RSS feed. Availability depends on the language/country and the place name Google recognizes.

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

Also fetch the front-page Top stories feed for the chosen language/country.

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

Interface/content language (hl), e.g. "en-US", "en-GB", "es-419", "fr". The short base (e.g. "en") is also used for the ceid parameter.

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

Edition country (gl), two-letter code, e.g. "US", "GB", "IN", "DE".

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

Cap the number of items taken from each feed. Search feeds return up to ~100 items and topic/geo feeds up to ~30; there is NO pagination, so this only trims a feed's snapshot. Set 0 for no cap.

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

Global cap on the total number of articles pushed across all feeds. Set 0 for no limit.

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

Resolve each news.google.com redirect to the real publisher article URL. This adds 1-2 extra HTTP requests per item and is the main run-cost and blocking driver. When off, the link field stays the Google News redirect URL.

## `scrapeArticleText` (type: `boolean`):

Fetch each resolved publisher page and extract the main body text, author, and published date. Requires 'Resolve real publisher URLs'. Best-effort only: many publishers paywall, 403, or show consent walls, so extraction can be empty for some items.

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

Google's RSS feeds tolerate datacenter proxies well. Consider RESIDENTIAL only for large runs that also resolve URLs / scrape article text, where the heavier requests get throttled sooner.

## Actor input object example

```json
{
  "queries": [
    "tesla when:7d",
    "site:reuters.com climate",
    "\"interest rates\" -crypto"
  ],
  "topics": [
    "TECHNOLOGY",
    "BUSINESS"
  ],
  "geoLocations": [
    "London",
    "San Francisco"
  ],
  "includeTopStories": false,
  "language": "en-US",
  "country": "US",
  "maxItemsPerQuery": 100,
  "maxItems": 1000,
  "resolveArticleUrls": false,
  "scrapeArticleText": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `articles` (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"
    ],
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidscrape/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"],
    "maxItems": 1000,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidscrape/google-news-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ],
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidscrape/google-news-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidscrape/google-news-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/5TLIPtaE027ICJ47A/builds/qXrFL8M7emPGqcl3u/openapi.json