# Google News Monitor — Keyword Tracker & Article Scraper (`guiltless_vivacity/google-news-monitor`) Actor

Monitor Google News for multiple keywords simultaneously. Extract headlines, sources, URLs, publication dates, and full article content. Perfect for brand monitoring, competitive intelligence, and market research.

- **URL**: https://apify.com/guiltless\_vivacity/google-news-monitor.md
- **Developed by:** [IrisVan](https://apify.com/guiltless_vivacity) (community)
- **Categories:** News, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Monitor — Keyword Tracker & Article Scraper

A powerful, fast, and reliable Apify Actor to monitor Google News for multiple keywords simultaneously. Extract headlines, sources, publication dates, URLs, and full article content without needing an API key.

### 🌟 Why use this Actor?

Whether you are doing brand monitoring, competitive intelligence, or market research, staying updated with the latest news is crucial. This Actor provides a robust solution to track multiple keywords on Google News with the following advantages:

- **Multi-Keyword Batching**: Monitor dozens of keywords in a single run.
- **No API Key Required**: Uses public Google News RSS feeds, saving you expensive API costs.
- **High Stability**: Bypasses complex anti-bot mechanisms by leveraging RSS feeds.
- **Full Content Extraction**: Optionally visit each article URL to extract the full text content using Playwright.
- **Deduplication**: Automatically removes duplicate articles that appear across different keyword searches.
- **Global Coverage**: Supports filtering by language and country.

### 🎯 Use Cases

- **Brand Monitoring**: Track mentions of your company, products, or executives in the news.
- **Competitive Intelligence**: Keep an eye on your competitors' product launches, funding news, and PR activities.
- **Market Research**: Monitor industry trends, regulatory changes, and emerging technologies.
- **Financial Analysis**: Track news related to specific stocks, cryptocurrencies, or macroeconomic events.
- **Content Curation**: Gather relevant news articles for newsletters, blogs, or social media posts.

### ⚙️ Input Configuration

The Actor accepts the following input parameters:

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `keywords` | Array | List of keywords or phrases to search on Google News. | `["Apify web scraping"]` |
| `language` | String | Language code for results (e.g., `en`, `zh`, `es`). | `en` |
| `country` | String | Country code for results (e.g., `US`, `CN`, `GB`). | `US` |
| `maxResultsPerKeyword` | Integer | Maximum number of articles to extract per keyword. | `20` |
| `timeRange` | String | Filter articles by publication time (`any`, `1h`, `1d`, `7d`, `30d`). | `1d` |
| `extractFullContent` | Boolean | If enabled, visits each URL to extract full article text. | `false` |
| `deduplicateResults` | Boolean | Remove duplicate articles across multiple keyword searches. | `true` |
| `proxyConfiguration` | Object | Proxy settings to avoid IP blocks (recommended for full content extraction). | `{ "useApifyProxy": true }` |

### 📊 Output Data Structure

The Actor stores its results in the default Apify Dataset. Each item represents a single news article and contains the following fields:

```json
{
  "keyword": "OpenAI",
  "title": "OpenAI plans new product for cybersecurity use - Axios",
  "url": "https://news.google.com/rss/articles/...",
  "sourceName": "Axios",
  "sourceUrl": "https://www.axios.com",
  "publishedAt": "2026-04-09T22:51:19.000Z",
  "snippet": "Scoop: OpenAI plans new product for cybersecurity use Axios...",
  "fullContent": "The full text of the article goes here... (if extractFullContent is true)",
  "scrapedAt": "2026-04-10T10:00:00.000Z"
}
````

### 💡 Tips for Best Results

1. **Use Specific Keywords**: Instead of broad terms like "AI", use specific phrases like "OpenAI funding" or "Tesla self-driving" for more relevant results.
2. **Enable Full Content Extraction Carefully**: Extracting full content requires visiting each article's website, which increases run time and proxy usage. Only enable it if you need the full text for analysis (e.g., sentiment analysis or summarization).
3. **Set Appropriate Time Ranges**: Use `1d` or `7d` for regular monitoring to avoid processing outdated news.

### 👨‍💻 Developer

Developed by **Manus AI**. If you have any feature requests or encounter issues, please open an issue in the Apify Console.

# Actor input Schema

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

List of keywords or phrases to search on Google News. Each keyword triggers a separate search.

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

Language code for Google News results (e.g. 'en' for English, 'zh' for Chinese).

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

Country code for Google News results (e.g. 'US', 'CN', 'GB').

## `maxResultsPerKeyword` (type: `integer`):

Maximum number of news articles to extract per keyword.

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

Filter news articles by publication time range.

## `extractFullContent` (type: `boolean`):

If enabled, the Actor will visit each article URL and extract the full article text. This increases run time but provides richer data.

## `deduplicateResults` (type: `boolean`):

Remove duplicate articles that appear across multiple keyword searches.

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

Proxy settings to avoid IP blocks. Recommended for large-scale runs.

## Actor input object example

```json
{
  "keywords": [
    "OpenAI",
    "electric vehicles",
    "Apple earnings"
  ],
  "language": "en",
  "country": "US",
  "maxResultsPerKeyword": 20,
  "timeRange": "1d",
  "extractFullContent": false,
  "deduplicateResults": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "Apify web scraping"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("guiltless_vivacity/google-news-monitor").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": ["Apify web scraping"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("guiltless_vivacity/google-news-monitor").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 '{
  "keywords": [
    "Apify web scraping"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call guiltless_vivacity/google-news-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google News Monitor — Keyword Tracker & Article Scraper",
        "description": "Monitor Google News for multiple keywords simultaneously. Extract headlines, sources, URLs, publication dates, and full article content. Perfect for brand monitoring, competitive intelligence, and market research.",
        "version": "1.0",
        "x-build-id": "VvMVRPHBaYgeifRKu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/guiltless_vivacity~google-news-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-guiltless_vivacity-google-news-monitor",
                "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/guiltless_vivacity~google-news-monitor/runs": {
            "post": {
                "operationId": "runs-sync-guiltless_vivacity-google-news-monitor",
                "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/guiltless_vivacity~google-news-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-guiltless_vivacity-google-news-monitor",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords to monitor",
                        "type": "array",
                        "description": "List of keywords or phrases to search on Google News. Each keyword triggers a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "zh",
                            "es",
                            "fr",
                            "de",
                            "ja",
                            "ko",
                            "pt",
                            "ru",
                            "ar"
                        ],
                        "type": "string",
                        "description": "Language code for Google News results (e.g. 'en' for English, 'zh' for Chinese).",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "CN",
                            "GB",
                            "DE",
                            "FR",
                            "JP",
                            "KR",
                            "BR",
                            "IN",
                            "AU"
                        ],
                        "type": "string",
                        "description": "Country code for Google News results (e.g. 'US', 'CN', 'GB').",
                        "default": "US"
                    },
                    "maxResultsPerKeyword": {
                        "title": "Max results per keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of news articles to extract per keyword.",
                        "default": 20
                    },
                    "timeRange": {
                        "title": "Time range",
                        "enum": [
                            "any",
                            "1h",
                            "1d",
                            "7d",
                            "30d"
                        ],
                        "type": "string",
                        "description": "Filter news articles by publication time range.",
                        "default": "1d"
                    },
                    "extractFullContent": {
                        "title": "Extract full article content",
                        "type": "boolean",
                        "description": "If enabled, the Actor will visit each article URL and extract the full article text. This increases run time but provides richer data.",
                        "default": false
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate results",
                        "type": "boolean",
                        "description": "Remove duplicate articles that appear across multiple keyword searches.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings to avoid IP blocks. Recommended for large-scale runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
