# Google News Monitor: Keyword & Topic Alerts via RSS (`fairfetch/google-news-monitor`) Actor Monitor public Google News RSS feeds for keywords, topics and places in 71 countries and 40 languages. Boolean and site: queries, time ranges, an alert mode that returns only new articles on scheduled runs, optional publisher URLs. Unofficial, not affiliated with Google. $1.50 per 1,000 articles. - **URL**: https://apify.com/fairfetch/google-news-monitor.md - **Developed by:** [Naveen Raja](https://apify.com/fairfetch) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 articles This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. 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 Monitor: Keyword & Topic Alerts via RSS Track **any keyword, company, person or topic on Google News** and get clean, structured JSON: headline, publisher, publish time, Google News link, optional direct publisher URL, related coverage and more. The Actor reads the **public Google News RSS feeds** (no sign-in) in **71 countries and 40 languages**, supports Google News search operators (`"exact phrase"`, `OR`, `-exclude`, `site:`, `intitle:`), time ranges from the past hour to custom dates, top stories, topic sections and local news. Turn on **Only new articles** and schedule the Actor: every run returns just the articles you haven't received yet. That's a news alert feed for Slack, email, a spreadsheet or a database, and you pay only for new articles. **Price: $1.50 per 1,000 articles** ($0.0015 per article) plus $0.0005 per run. No subscription, no extra usage fees. Platform and proxy costs are included. Error rows and the run summary are free. > **Unofficial.** This Actor is not affiliated with, endorsed by or sponsored by Google. Google News is a trademark of Google LLC. See [Legal](#legal) before you use the data. ### What you get - One item per article with the same fields for every feed: `title`, `publishedAt` (ISO 8601 UTC), `sourceName`, `sourceDomain`, `sourceUrl`, `googleNewsUrl`, `publisherUrl` (optional), `snippet`, `relatedArticles`, `articleId`, `language`, `country`, `query`, `position`, `isNew`, `scrapedAt`, plus `status` (`ok` for an article, `error` for a free error row) and `error` / `errorKind` on error rows. - **Search queries** with Google News operators, **topic sections** (Top stories, World, Nation, Business, Technology, Entertainment, Sports, Science, Health), **local news** for places, or any **news.google.com URL** (for example a company topic page). - **Time filters**: past hour, 24 hours, 7 days, 30 days, or a custom date range. Every article's publish date is checked again, so nothing older slips through. - **More than 100 articles per query**: Google caps each feed at about 100 articles; "Split long time ranges by day" fetches one feed per day (tested: 711 articles for one query over 7 days). - **Alert mode** (`onlyNew`) that remembers what each query already returned, across runs. - **De-duplication** across queries in a run (same article ID, or same headline from the same publisher). - **Publisher URLs** (optional, best effort): decode Google News links into the publisher's own article URL. - **Clear errors**: a query, place or URL that can't be read gets a free error row with the reason; the other queries still run. - Built for automation: a predictable schema, pay-per-event pricing without usage fees, limited permissions, a `SUMMARY` record, and a clean stop when your spending limit or the run's time limit is reached. ### Use cases - **Brand and PR monitoring**: follow mentions of your company, products and executives in the countries and languages you care about. Schedule hourly with "Only new articles" for near-real-time alerts. - **Competitor news**: watch competitors' launches, funding, hires and lawsuits with queries like `"Acme Corp" OR "Acme Inc" -jobs`. - **Finance and market news**: track companies, sectors, central banks or commodities, e.g. `"interest rates" site:reuters.com` or `intitle:Nvidia`. - **Daily digests and newsletters**: collect the day's headlines with publisher, date and link into a spreadsheet, an email or a team channel. - **Media research and dashboards**: count coverage by publisher, country or day; compare editions (e.g. US vs. India vs. Germany). - **Local news**: monitor a city or region with the local-news feed. ### How to use 1. Add one or more **Search queries** (one per line), and/or pick **Topics**, **Local news** places or **Google News URLs**. 2. Choose the **Country** and **Language** (default: United States, English). 3. Pick a **Time range** (default: past 7 days) or a custom **From / To date**. 4. Set **Max articles per query** (default 100; 0 = everything Google returns). 5. For alerts: turn on **Only new articles**, save the input as a **task** and create a **Schedule** for it in Apify Console (e.g. every hour). Connect the results to Slack, email, Google Sheets, Zapier, Make or a webhook with Apify integrations. 6. Download the results as JSON, CSV, Excel or via the API. A run summary is saved as the `SUMMARY` record in the run's key-value store. #### Google News search operators (verified) | Operator | Example | Meaning | |---|---|---| | `"..."` | `"electric vehicles"` | Exact phrase | | `OR` | `Nvidia OR AMD` | Either term | | `-` | `Tesla -stock` | Exclude a word | | `site:` | `tariffs site:reuters.com` | Only one publisher's site | | `intitle:` | `intitle:Nvidia` | Word must be in the headline | | `when:` | `apple when:1h` | Time range (the **Time range** field adds this for you) | | `after:` / `before:` | `apple after:2026-10-01 before:2026-10-05` | Date range (the **From / To date** fields add these for you) | If your query (or a pasted Google News URL) already contains `when:`, `after:` or `before:`, your operator is used for it instead of the **Time range** / date settings. A google.com **News tab** link (`https://www.google.com/search?q=...&tbm=nws`) pasted into **Google News URLs** is turned into a search query. #### Input example ```json { "queries": ["\"Acme Corp\" OR \"Acme Inc\"", "Tesla -stock", "\"interest rates\" site:reuters.com"], "topics": ["TOP_STORIES", "BUSINESS"], "locations": ["London"], "country": "US", "language": "auto", "timeRange": "1d", "maxArticlesPerQuery": 0, "onlyNew": true, "trackingId": "my-news-alerts", "deduplicate": true, "resolvePublisherUrls": false } ``` #### Output example A real item from a cloud test run of this version (query `Federal Reserve`, with **Resolve publisher URLs** on; long IDs shortened): ```json { "query": "Federal Reserve", "feedType": "search", "status": "ok", "position": 2, "title": "The Fed's Beige Book is Mentioning Diesel a Lot More Than Before. What That Could Mean for Consumer Prices.", "publishedAt": "2026-10-19T17:57:10Z", "sourceName": "International Business Times", "sourceDomain": "ibtimes.com", "sourceUrl": "https://www.ibtimes.com", "googleNewsUrl": "https://news.google.com/rss/articles/CBMiugFBVV95cUxPTlNpTEx4d2hG...?oc=5", "publisherUrl": "https://www.ibtimes.com/feds-beige-book-mentioning-diesel-lot-more-before-what-that-could-mean-consumer-prices-3808735", "snippet": "The Fed's Beige Book is Mentioning Diesel a Lot More Than Before. What That Could Mean for Consumer Prices. - International Business Times", "relatedArticles": [], "articleId": "CBMiugFBVV95cUxPTlNpTEx4d2hG...", "language": "en", "country": "US", "isNew": null, "scrapedAt": "2026-10-19T23:58:03Z", "error": null, "errorKind": null } ``` Items from **Top stories** and topic sections usually also list `relatedArticles`: other publishers' coverage of the same story, each with `title`, `sourceName` and `googleNewsUrl`. #### Output fields | Field | Description | |---|---| | `query`, `feedType` | The query, topic code (e.g. `BUSINESS`), place or URL that found the article, and `search` / `topic` / `location` / `url` | | `status` | `ok` for an article (charged), `error` for a free error row | | `position` | 1-based position within this query's results in this run (after sorting) | | `title` | Headline, without the " - Publisher" suffix Google adds | | `publishedAt` | Publish time from the feed, ISO 8601 UTC | | `sourceName`, `sourceDomain`, `sourceUrl` | Publisher name, domain and home page (from the feed's `` element) | | `googleNewsUrl` | Link on news.google.com; opens the article in a browser | | `publisherUrl` | Direct article URL on the publisher's site, when **Resolve publisher URLs** is on and decoding worked; otherwise `null` | | `snippet` | Plain text of the feed's description (see FAQ: Google no longer puts article summaries in its feeds) | | `relatedArticles` | Other coverage of the same story (topic and top-story feeds) | | `articleId` | Stable Google News article ID (same ID on every run) | | `language`, `country` | The Google News edition the article came from | | `isNew` | `true` in alert mode (every returned article is new to this alert memory), otherwise `null` | | `scrapedAt` | When this run read the feed | | `error`, `errorKind` | Error rows only: why the feed returned nothing, and `invalid_input`, `not_found`, `blocked`, `source_error` or `internal_error` | The dataset has three views: **Articles** (overview table), **All fields** and **Errors**. #### Error rows (free) If a query, topic, place or URL can't be read, the Actor adds one **free** row for it (`status: "error"`) with the reason, and the other entries still run. Examples: an unknown place ("Google News has no feed for this topic, place or URL"), a URL that isn't on news.google.com, a link to a single article instead of a feed, or a feed Google blocked. An invalid setting for the whole run (for example an unknown country, a bad date or an unsupported proxy group) gives one error row with `feedType: "input"`. Error rows are never charged. ### Alert mode: only new articles With **Only new articles** on, the Actor stores a short hash of every article it returned for each query, topic, place or URL in a named key-value store in your Apify account (`google-news-monitor-seen`). It stores only hashes, never article data. Each later run skips those articles. Real test (8 feeds, past 24 hours, US edition): | Run | Articles returned | Already seen (skipped, free) | |---|---|---| | 1st run | 467 | 0 | | 2nd run, 1 minute later | 0 | 483 | | 3rd run, 7 minutes later | 42 | 448 | Good to know: - "New" means *not returned to you before*, not "published since the last run". An older article that newly enters Google's top results for your query is returned once. - Articles are only remembered once they are actually delivered. If a run stops at your spending limit, the rest are returned by the next run. - With **Remove duplicates across queries** on, an article returned for one query is not returned again for another query, in this run or later runs. - **Tracking ID**: leave it empty and each saved task gets its own memory (a run without a task gets one memory per set of queries plus country and language). Set your own ID to share one memory between tasks, or to keep the memory when you change the query list. Monitors that ran before version 1.1 without an ID keep what they already received (the old shared memory is read too). - Changing the time range or max articles doesn't reset the memory. Use a new **Tracking ID** to start fresh. - An article is remembered until it has been **missing from its feed for 180 days** (up to 20,000 articles per query). Articles that stay in Google's results are never returned again. - Don't run two alert runs with the same Tracking ID at the same time; the later one wins when saving. ### Getting more than 100 articles per query Each Google News feed returns at most about 100 articles (we saw 100 to 104), ranked by relevance. With **Split long time ranges by day** on, a search with a 24-hour, 7-day, 30-day or custom date range is fetched as one feed per day, newest day first, and the Actor stops as soon as **Max articles per query** (or your remaining spending limit) is reached. In our test, `Tesla` over 7 days returned **711 unique articles from 8 requests in 5 seconds**. Topic, top-story and local feeds can't be split (they have no date operators). ### Publisher URLs (optional, best effort) Google News RSS links point to `news.google.com/rss/articles/...`, which redirects to the publisher in a browser. With **Resolve publisher URLs** on, the Actor also tries to decode them to the publisher's own URL. - It uses an **undocumented Google News web endpoint**, the same one the Google News site uses. Google can change or block it at any time, so this feature may stop working without notice. - It **fails soft**: if decoding fails, the article is still returned with its `googleNewsUrl` and `publisherUrl: null`, and the run never fails because of it. After two failed batches in a row the Actor stops trying for the rest of the run and says so in the `SUMMARY` record. - In our cloud tests on 19 and 20 Oct 2026, every link was decoded (200 of 200, from Apify servers, directly and through the datacenter proxy). - It costs about 1 extra request per article (one page of about 125 KB, plus one small request per 10 articles), so runs take a little longer: roughly 0.5 to 3 seconds per 10 articles (measured: 120 articles decoded in 6 seconds). - It's off by default. If you only need to open articles, `googleNewsUrl` works in any browser. ### Countries and languages 71 countries and 40 languages, verified against Google News (each combination is a Google News "edition"). Examples: United States (English, Spanish), United Kingdom, India (English, Hindi, Bengali, Marathi, Tamil, Telugu, Malayalam, Gujarati), Canada (English, French), Germany, France, Spain, Italy, Brazil, Mexico, Japan, South Korea, China, Taiwan, Indonesia, Turkey, Saudi Arabia, Israel, Nigeria, South Africa and many more. Leave **Language** on **Auto** to use the country's main language. If you pick a language a country has no edition for (for example Germany + English), the Actor uses the country's main language and notes it in the run summary. (Google itself would silently switch you to a different country.) ### Pricing Pay per event, no subscription and no extra usage fees: | Event | Price | |---|---| | `article`: one article in the dataset | **$0.0015** ($1.50 per 1,000) | | Actor start (standard Apify event, once per run) | $0.0005 | Examples: - 10 queries, past 24 hours, 100 articles each: 1,000 articles = **$1.50**. - Hourly alert run for 5 brand queries that finds 3 new articles per hour on average: 72 articles plus 24 runs a day = **about $0.12 per day**. A run that finds nothing new costs only the start event ($0.0005), so an hourly schedule that never finds anything costs about $0.36 a month. - The prefilled example (2 queries, 10 articles each): **about $0.03** ($0.0305). Already-seen articles, skipped duplicates, error rows and the `SUMMARY` record are free. Set **Maximum cost per run** in the run options (or `maxTotalChargeUsd` in the API) to cap spending: the Actor stops cleanly at the cap, never fetches feeds it can't charge for, and everything returned so far stays in the dataset. ### Use it from the API Run synchronously and get the articles in one call (keep your Apify API token in the `APIFY_TOKEN` environment variable): ```bash curl -X POST "https://api.apify.com/v2/acts/fairfetch~google-news-monitor/run-sync-get-dataset-items?maxTotalChargeUsd=0.30" \ -H "Authorization: Bearer $APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"queries": ["Nvidia earnings"], "timeRange": "1d", "maxArticlesPerQuery": 20}' ``` The items include free error rows when a query fails; filter on `status == "ok"` if you only want articles. Each run also writes a `SUMMARY` record with per-query counts, the edition used, stop reasons and any errors. ### Performance and limits Measured on the Apify platform (256 MB, 19 and 20 Oct 2026): - The prefill (2 queries x 10 articles): 20 articles, 3.9 seconds in total. - 6 queries x 20 articles with publisher URLs: 120 articles, all 120 publisher URLs decoded, 6 seconds of work, 15 MB downloaded. - 3 queries x 5 articles with publisher URLs: about 1.5 seconds of work with direct requests, 6 to 12 seconds through Apify's datacenter proxy. Limits to know: - About 100 articles per feed (use **Split long time ranges by day** for more). Top stories return about 35 to 40 articles, topic and local feeds about 60 to 90 (some older than 24 hours, which the time filter removes). - Google ranks search feeds by relevance; **Order: Newest first** sorts them by date before applying **Max articles per query**. - Requests are polite: at most 3 at a time by default, retries with exponential backoff (longer when Google signals rate limiting), and timeouts. - If Google blocks a run, the Actor switches to Apify's datacenter proxy with a fresh IP for each retry. If Google keeps blocking (10 blocked answers in a row), it stops sending requests, reports the remaining feeds as `blocked` and ends the run instead of waiting until the timeout. - **Run timeout**: the platform needs up to about 7 seconds to finish a run after the Actor exits, so the Actor stops reading new feeds 16 to 70 seconds before the run's timeout (depending on the timeout) and stops pushing rows 12 to 20 seconds before it. Rows that were read but not pushed are not charged, and the `SUMMARY` is always written. Tested: 20-, 30- and 45-second timeouts with large feeds end SUCCEEDED. The Actor needs a timeout of at least 20 seconds: with less, it stops at once with "Run timeout too short" and a free error row. Use 30 seconds or more if you set a timeout. ### FAQ **Does it return the full article text?** No. Google News RSS feeds contain the headline, publisher, publish time and a link, not the article body. Use `publisherUrl` (or open `googleNewsUrl`) to read the article on the publisher's site, subject to the publisher's terms and paywalls. **Why is the `snippet` so short?** Google no longer includes article summaries in its RSS feeds. For search feeds the description is just the headline and publisher; for top stories and topic sections it lists related headlines (also available as `relatedArticles`). The Actor returns that text as clean plain text and doesn't invent summaries. **Does it include images, authors or article categories?** No, the feeds don't contain them. **Why did I get fewer articles than "Max articles per query"?** Google returned fewer for that query and time range, the time filter removed older items, or the articles were duplicates of another query or already seen in alert mode. The `SUMMARY` record shows the count for each reason. **How fresh is the data?** Feeds are read live on every run. New articles usually appear in Google News within minutes of publication. **Do I need proxies or a Google account?** No. The feeds are public and the Actor reads them without signing in. Requests go out directly; if Google blocks a run on the Apify platform, the Actor switches to Apify's datacenter proxy by itself. You can also choose Apify Proxy (datacenter) or your own proxy URLs. Residential and Google SERP proxy groups are not supported: a run that selects them stops at once with "Invalid input" and no articles are charged (only the standard Actor start event). **Can I monitor many queries?** Yes, there is no hard limit. Feeds are fetched 3 at a time by default and each takes well under a second in our tests, so even long query lists finish quickly (publisher URL decoding is the slow part). **What happens if one query fails?** The others still run. The failed one gets a free error row with the reason, and it's listed in the `SUMMARY` record and the status message. A run where every entry was wrong (for example only unknown places) still ends as SUCCEEDED, with the error rows; a run ends as FAILED only when nothing could be returned because of a problem on our side, such as Google blocking every request. ### What's new in 1.1 (October 2026) - **Free error rows**: a query, topic, place or URL that can't be read now adds a row with `status: "error"`, `error` and `errorKind` (before: only in the `SUMMARY`). Every row has a `status` field; filter on `status == "ok"` if you only want articles. New dataset view: **Errors**. - **Input mistakes end SUCCEEDED**: a run whose entries are all wrong (for example only unknown places) or whose settings are invalid now ends SUCCEEDED with error rows and an "Invalid input" or "No articles returned" status, instead of FAILED. One bad URL no longer stops the other queries, and a google.com News-tab URL is turned into a search query. - **Tracking ID**: it has no default value any more. Without one, each saved task (or each set of queries plus country and language) gets its own alert memory; monitors that ran before 1.1 without an ID keep what they already received. - **Time limit, spending limit, blocks and migrations**: the Actor stops cleanly before the run's timeout, never fetches what your spending limit can't pay for, switches to a datacenter proxy if Google blocks it, and never repeats or re-charges articles after a platform migration. - **Proxies**: only datacenter proxies (Apify's or your own); residential and Google SERP groups are refused. - **Price**: articles still cost $0.0015 each; the per-run start fee is now $0.0005 (was $0.00005), so runs that find nothing cover their own platform cost. ### Legal - **Unofficial.** This Actor is not affiliated with, endorsed by or sponsored by Google. Google News is a trademark of Google LLC; all other names are the property of their owners. - **What it reads.** Only public Google News RSS feed URLs, without signing in, plus (only when you turn on **Resolve publisher URLs**) Google News article pages and an undocumented Google News endpoint to find publisher links. It doesn't bypass paywalls or access controls and doesn't collect personal data beyond what appears in public headlines (such as names of public figures). - **Google's terms.** Every Google News feed carries a copyright notice saying the feed is made available for rendering results in a personal feed reader for personal, non-commercial use, and that other uses are prohibited. Google News' robots.txt does not allow automated access to the RSS feed paths. The headlines and articles belong to their publishers. - **Your responsibility.** You decide what you do with the data. Check that your use complies with Google's terms, the publishers' rights and the laws that apply to you (such as copyright and data-protection law), and get legal advice before any commercial use or redistribution. # Actor input Schema ## `queries` (type: `array`): One Google News search per line. Google News operators work: "exact phrase", OR, -exclude, site:reuters.com, intitle:word. Each query returns at most about 100 articles per feed (see "Split long time ranges by day" to get more). ## `topics` (type: `array`): Google News section feeds for the selected country and language. Top stories and each section return about 35 to 90 current articles. Sections ignore the search operators; the time range is applied after download. ## `locations` (type: `array`): Google News local-news feeds for cities, regions or countries, one per line (e.g. London, Austin Texas, Bavaria). ## `feedUrls` (type: `array`): Optional. Paste any news.google.com search, topic or section URL (for example a company or person topic page). It is converted to its RSS feed. Its own hl/gl/ceid parameters are kept; otherwise the country and language below are used. A google.com News-tab search URL (…/search?q=…\&tbm=nws) is turned into a search query. Any other URL is reported as a free error row and the other entries still run. ## `country` (type: `string`): Which country edition of Google News to read. It decides the ranking and local sources. ## `language` (type: `string`): News language. "Auto" picks the country's main Google News language. If the country has no edition in the chosen language (e.g. Germany + English), the country's main language is used and the run summary says so. ## `timeRange` (type: `string`): Only articles published within this period before the run. Added to search queries as Google's when: operator and checked again on every article's publish date. ## `dateFrom` (type: `string`): Custom date range start (UTC day, inclusive). Overrides "Time range". Uses Google's after:/before: operators. ## `dateTo` (type: `string`): Custom date range end (UTC day, inclusive). Leave empty for "until now". ## `splitByDay` (type: `boolean`): Google returns at most about 100 articles per feed. With this on, search queries with a 24-hour, 7-day, 30-day or custom date range are fetched as one feed per day (newest day first), so busy topics can return up to about 100 articles per day. Uses one extra request per day; it stops as soon as "Max articles per query" is reached. ## `maxArticlesPerQuery` (type: `integer`): Maximum articles returned (and charged) per query, topic, place or URL. 0 = no limit (all articles Google returns, about 100 per feed). ## `sortBy` (type: `string`): "Newest first" sorts by publish date before "Max articles per query" is applied. "Google relevance" keeps Google's ranking. ## `onlyNew` (type: `boolean`): Remember which articles each query has returned (as short hashes, in a named key-value store in your account) and return only articles not returned before. Schedule the Actor (e.g. hourly or daily) to get an alert feed and pay only for new articles. The first run returns the current articles. An article is remembered until it has been missing from its feed for 180 days. ## `trackingId` (type: `string`): Name of the alert memory used by "Only new articles". Leave empty and each saved task gets its own memory (a run without a task gets one per set of queries + country/language). Use the same ID to share a memory, or to keep it when you edit the query list. Monitors that ran before version 1.1 without an ID keep what they already received. Letters, numbers, dashes and underscores. ## `deduplicate` (type: `boolean`): Return each article once per run, under the first query that found it (and, in alert mode, not again under another query later). ## `resolvePublisherUrls` (type: `boolean`): Google News RSS links point to news.google.com. With this on, the Actor also tries to decode each link to the publisher's article URL (publisherUrl). It uses an undocumented Google News web endpoint that can change or stop working at any time: if decoding fails, the article is still returned with its Google News link and publisherUrl empty, and the run never fails because of it. Adds about 1 request per article (roughly 1 to 3 seconds per 10 articles). ## `maxConcurrency` (type: `integer`): Upper limit of simultaneous requests to Google News. Keep it low to stay polite and avoid rate limits. ## `requestTimeoutSecs` (type: `integer`): Timeout for a single HTTP request. ## `maxRetries` (type: `integer`): Retries for network errors, HTTP 429 and 5xx responses (exponential backoff, honours Retry-After). ## `proxyConfiguration` (type: `object`): Not needed normally: requests go out directly, and if Google blocks a run on the Apify platform the Actor switches to Apify's datacenter proxy by itself. You can also choose Apify Proxy (datacenter) or your own proxy URLs. Residential and Google SERP proxy groups are not supported: a run that selects them stops with "Invalid input" and no articles are charged (only the standard Actor start event). Apify Proxy use is included in the price. ## Actor input object example ```json { "queries": [ "\"Acme Corp\" OR \"Acme Inc\"", "Tesla -stock", "electric vehicles site:reuters.com", "intitle:\"interest rates\"" ], "topics": [ "TOP_STORIES", "BUSINESS" ], "locations": [ "London", "San Francisco" ], "feedUrls": [ "https://news.google.com/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGRqTVhZU0FtVnVHZ0pWVXlnQVAB?hl=en-US&gl=US&ceid=US:en" ], "country": "US", "language": "auto", "timeRange": "7d", "splitByDay": false, "maxArticlesPerQuery": 10, "sortBy": "newest", "onlyNew": false, "deduplicate": true, "resolvePublisherUrls": false, "maxConcurrency": 3, "requestTimeoutSecs": 30, "maxRetries": 4, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `articles` (type: `string`): All articles from this run as JSON. ## `summary` (type: `string`): Per-feed counts (articles in feeds, filtered, already seen, pushed), status, edition used, stop reasons and any errors. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "queries": [ "electric vehicles", "Nvidia OR AMD" ], "maxArticlesPerQuery": 10 }; // Run the Actor and wait for it to finish const run = await client.actor("fairfetch/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "queries": [ "electric vehicles", "Nvidia OR AMD", ], "maxArticlesPerQuery": 10, } # Run the Actor and wait for it to finish run = client.actor("fairfetch/google-news-monitor").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": [ "electric vehicles", "Nvidia OR AMD" ], "maxArticlesPerQuery": 10 }' | apify call fairfetch/google-news-monitor --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,fairfetch/google-news-monitor" } } } ``` 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 ` 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/7RzPaYz9VuTe32B0M/builds/MeDea9wSAX5fZehkM/openapi.json