# Google News Scraper - Articles, Sources, Real URLs, No API Key (`renzomacar/google-news-scraper`) Actor

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

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 - Articles, Sources, Real URLs, No API Key

### Scrape Google News into clean structured data - with the real publisher URL, not the Google redirect

This Google News scraper turns any keyword search, topic section, top-stories feed, or location feed into structured, export-ready data. For every article you get the headline, the **real resolved publisher URL** (not the useless `news.google.com/rss/articles/...` redirect link), the source/publisher name, the publish date in ISO 8601, a clean text snippet, and the image when available.

No Google News API key. No login. No browser automation. Just fast, cheap HTTP requests against the public Google News RSS feeds, with the redirect links decoded into the actual article URLs you can click, crawl, or store.

If you have used other Google News tools and ended up with thousands of `news.google.com` redirect links that you could not open programmatically, this actor solves exactly that problem. Resolving the real article URL is the single most important feature when you actually want to *use* the data downstream.

### Why this scraper is different

Most Google News scrapers hand back the Google redirect link (`https://news.google.com/rss/articles/CBMi...`). That link is encoded and cannot be opened, crawled, or de-duplicated reliably - it changes per session and is bound to Google. This actor decodes that token through Google's own resolution endpoint and returns the genuine publisher URL, for example `https://www.nytimes.com/2026/06/10/business/economy/back-office-workers-ai.html`. Each resolved URL is correctly paired back to its own article, so titles, sources, and URLs always line up.

You also get four input modes in one actor - keyword search, top stories, topic sections, and local/geo headlines - plus full control over language and country.

### What data can you extract?

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Article headline as shown on Google News |
| `url` | string | **Real publisher article URL** (resolved from the Google redirect) |
| `urlResolved` | boolean | `true` if the real URL was decoded, `false` if only the redirect is available |
| `googleNewsUrl` | string | The original Google News redirect link (kept for reference) |
| `source` | string | Publisher / source name (e.g., "The New York Times") |
| `sourceUrl` | string | Publisher homepage URL |
| `pubDate` | string | Publish date in ISO 8601 (e.g., `2026-06-10T09:02:42.000Z`) |
| `description` | string | Clean text snippet / summary of the article |
| `image` | string | Article image URL when available |
| `language` | string | Language code used for the request (e.g., `en-US`) |
| `country` | string | Country code used for the request (e.g., `US`) |
| `query` | string | The search query (search mode) |
| `topic` | string | The topic section (topic mode) |
| `mode` | string | Which mode produced the record |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was collected |

### Use cases

- **Media monitoring & PR** - Track every time a brand, person, product, or competitor is mentioned in the news, with direct links to the original coverage.
- **Brand & reputation tracking** - Watch keyword feeds and store the real article URLs for clipping reports and sentiment analysis.
- **Market & competitive intelligence** - Follow an industry topic (BUSINESS, TECHNOLOGY) and build a dated dataset of headlines and sources.
- **News aggregation apps** - Power a newsfeed product with clean titles, snippets, images, and clickable publisher links.
- **SEO & content research** - See which publishers rank in Google News for a query and what angles they cover.
- **AI / LLM pipelines & RAG** - Feed an LLM real, fetchable article URLs (not dead redirects) so it can read and summarize the source.
- **Academic & data science** - Collect structured, time-stamped news data for research on coverage, framing, and media trends.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | Yes | `search` | `search`, `topStories`, `topic`, or `location` |
| `query` | string | When `mode=search` | `artificial intelligence` | Keyword(s). Supports Google News operators like `"openai" OR "anthropic"` |
| `topic` | string | When `mode=topic` | `BUSINESS` | One of TOP, WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH |
| `location` | string | When `mode=location` | - | City / place name for local headlines (e.g., "New York") |
| `language` | string | No | `en-US` | Interface language code (e.g., `en-US`, `es-419`, `fr`, `de`) |
| `country` | string | No | `US` | Two-letter country code (e.g., `US`, `GB`, `ES`, `IN`) |
| `maxItems` | integer | No | `50` | Maximum number of articles to return (1-100) |
| `resolveUrls` | boolean | No | `true` | Decode Google redirect links into the real publisher URL |

### Example input

```json
{
  "mode": "search",
  "query": "artificial intelligence",
  "language": "en-US",
  "country": "US",
  "maxItems": 25,
  "resolveUrls": true
}
````

### Example output

```json
{
  "title": "The Hidden Workers Most Threatened by A.I. - The New York Times",
  "url": "https://www.nytimes.com/2026/06/10/business/economy/back-office-workers-ai.html",
  "urlResolved": true,
  "googleNewsUrl": "https://news.google.com/rss/articles/CBMihgFBVV95cUx...?oc=5",
  "source": "The New York Times",
  "sourceUrl": "https://www.nytimes.com",
  "pubDate": "2026-06-10T09:02:42.000Z",
  "description": "The Hidden Workers Most Threatened by A.I.",
  "image": null,
  "language": "en-US",
  "country": "US",
  "query": "artificial intelligence",
  "mode": "search",
  "scrapedAt": "2026-06-12T10:31:11.000Z"
}
```

### How it works

The actor fetches the public Google News RSS feed for your chosen mode, parses each item (title, link, source, date, description, image), de-duplicates the results, and then resolves each Google redirect link into the real publisher URL by calling Google's own article-resolution endpoint in efficient batches. The whole pipeline is HTTP-only - no headless browser - which keeps runs fast and inexpensive. If resolution ever fails for an item, you still keep the headline, source, date, snippet, and the original Google link, and `urlResolved` is set to `false`.

### Pricing

This actor uses pay-per-event pricing: a small charge per run start plus a small charge per article returned. You only pay for the articles you actually get. There are no monthly platform fees beyond your Apify plan.

### Frequently asked questions

#### Do I need a Google News API key?

No. Google News does not offer a public articles API. This actor uses the public RSS feeds plus URL resolution, so there is nothing to sign up for and no key to manage.

#### Does it return the real article URL or the Google redirect?

The real publisher URL. With `resolveUrls` enabled (default), every Google News redirect link is decoded into the actual article URL you can open, crawl, or store. The original redirect is also kept in `googleNewsUrl`.

#### Can I scrape Google News in other languages or countries?

Yes. Set `language` (e.g., `es-419`, `fr`, `de`) and `country` (e.g., `ES`, `GB`, `IN`) to get localized results, just like changing your Google News region.

#### What modes are supported?

Keyword search, top stories, topic sections (Business, Technology, Sports, Science, Health, and more), and local/geo headlines for a city or place.

#### How many articles can I get per run?

Up to 100 articles per run via `maxItems`. Run the actor multiple times with different queries, topics, or regions to build a larger dataset.

#### Is scraping Google News legal?

This actor only reads publicly available Google News RSS feeds. You are responsible for complying with Google's terms and applicable laws, and for how you use the collected data. Review the feed's usage notes and consult your legal counsel for commercial use.

#### What if an article URL cannot be resolved?

You still get the headline, source, publish date, snippet, and the original Google link. The `urlResolved` field tells you which records have the real URL so you can filter if needed.

#### Can I use the output with other tools?

Yes. Export to JSON, CSV, or Excel from the Apify dataset, or pull it via the Apify API. The resolved URLs make the data immediately usable in crawlers, dashboards, spreadsheets, and LLM pipelines.

# Actor input Schema

## `mode` (type: `string`):

How to fetch news: keyword search, top stories, a topic section, or a location.

## `query` (type: `string`):

Keyword(s) to search for. Required when mode = search. Supports Google News operators (e.g. "openai" OR "anthropic").

## `topic` (type: `string`):

Topic section (used when mode = topic).

## `location` (type: `string`):

City / place name for local headlines (used when mode = location). e.g. "New York", "London".

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

Interface language code, e.g. en-US, es-419, fr, de.

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

Two-letter country code, e.g. US, GB, ES, IN.

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

Maximum number of articles to return.

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

Decode Google News redirect links into the real publisher URL (recommended). Slightly slower but gives you the actual article link.

## Actor input object example

```json
{
  "mode": "search",
  "query": "artificial intelligence",
  "topic": "BUSINESS",
  "language": "en-US",
  "country": "US",
  "maxItems": 50,
  "resolveUrls": true
}
```

# Actor output Schema

## `results` (type: `string`):

All result items as JSON.

# 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 = {
    "query": "artificial intelligence"
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/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 = { "query": "artificial intelligence" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google News Scraper - Articles, Sources, Real URLs, No API Key",
        "version": "0.1",
        "x-build-id": "259d3CFgqFlSojxYr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renzomacar~google-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renzomacar-google-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/renzomacar~google-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-renzomacar-google-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/renzomacar~google-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-renzomacar-google-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "topStories",
                            "topic",
                            "location"
                        ],
                        "type": "string",
                        "description": "How to fetch news: keyword search, top stories, a topic section, or a location.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword(s) to search for. Required when mode = search. Supports Google News operators (e.g. \"openai\" OR \"anthropic\")."
                    },
                    "topic": {
                        "title": "Topic",
                        "enum": [
                            "TOP",
                            "WORLD",
                            "NATION",
                            "BUSINESS",
                            "TECHNOLOGY",
                            "ENTERTAINMENT",
                            "SPORTS",
                            "SCIENCE",
                            "HEALTH"
                        ],
                        "type": "string",
                        "description": "Topic section (used when mode = topic).",
                        "default": "BUSINESS"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City / place name for local headlines (used when mode = location). e.g. \"New York\", \"London\"."
                    },
                    "language": {
                        "title": "Language (hl)",
                        "type": "string",
                        "description": "Interface language code, e.g. en-US, es-419, fr, de.",
                        "default": "en-US"
                    },
                    "country": {
                        "title": "Country (gl)",
                        "type": "string",
                        "description": "Two-letter country code, e.g. US, GB, ES, IN.",
                        "default": "US"
                    },
                    "maxItems": {
                        "title": "Max articles",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of articles to return.",
                        "default": 50
                    },
                    "resolveUrls": {
                        "title": "Resolve real article URLs",
                        "type": "boolean",
                        "description": "Decode Google News redirect links into the real publisher URL (recommended). Slightly slower but gives you the actual article link.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
