# Google News Scraper (`silentflow/google-news-scraper`) Actor

Scrape Google News by keyword, topic, or section. Get real publisher article URLs, not Google redirect links, plus descriptions, images, sources, and publish dates. Break past the 100-result limit, cover 70+ countries and languages, and export to JSON, CSV, or Excel for media monitoring and PR.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

**Get real, ready-to-click article URLs from Google News, not redirect links you have to decode yourself.** Search any keyword or browse a topic and get titles, descriptions, images, and publish dates in structured JSON. 10 articles with full details in under 4 seconds.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/LXuvYiPGOcJBdW24A/records/how-it-works-v2.png)

### ✨ Why teams choose this over other Google News scrapers

Ever run a Google News scraper and gotten a dataset full of `news.google.com/rss/articles/CBMi...` links instead of the actual article? Ever had to write your own script just to turn those links into something clickable? Ever hit a wall at exactly 100 results and wondered why?

- 🔗 **Real article URLs, on by default.** Other Google News scrapers ship Google's internal redirect links out of the box and make you flip on a "decode" option they warn is slow. Here, every `url` field is already the publisher's real link. No extra setup, no extra step.
- 📝 **Descriptions and preview images included from the first run.** Most competitors turn this off by default too. You get the article snippet and the `og:image` preview picture without touching a single setting.
- 📈 **Break past the 100-article ceiling.** Google News caps a single feed at around 100 results. Competitors stop there. This scraper automatically slices your time window into smaller chunks and stitches the results back together with zero duplicates, so a `maxItems` of 220 or more actually returns 220 or more.
- 🌍 **70+ country and language combinations.** Search news the way people actually read it locally: US English, French from France or Quebec, Brazilian Portuguese, Simplified or Traditional Chinese, Arabic, Hindi, and dozens more.
- 🎯 **Search operators just work.** Use `site:reuters.com`, `"exact phrase"`, `OR`, and `-exclude` the same way you would on Google itself. No special query language to learn.
- 🗞️ **Predefined topics and custom sections.** Pull the World, Business, Technology, Entertainment, Sports, Science, or Health feed directly, or point the scraper at any Google News section URL for a niche category.
- ⚡ **Zero configuration.** No login, no API key, no cookies to manage. Add a keyword or pick a topic and start the run.
- 💰 **Pay for the articles you actually get delivered.** No fixed monthly commitment standing between you and a first test run.

### 🎯 What you can do with Google News data

| Team | What they build |
|------|-----------------|
| **PR and communications** | Real-time brand and executive mention monitors that alert the moment a competitor or your own company gets covered |
| **Market and finance research** | News-driven trading signals and sector watchlists built from headline volume and sentiment over time |
| **Growth and SEO** | Content gap trackers that show which publishers already cover a keyword you're targeting, and how often |
| **Data science and NLP** | Labeled datasets of headlines, descriptions, and publish dates for sentiment models and topic classifiers |
| **Competitive intelligence** | Daily digests of every article mentioning a competitor's product launches or funding rounds |
| **Crisis communications** | Early-warning feeds that catch a story spreading across outlets within the hour it breaks |
| **Academic and policy research** | Longitudinal datasets tracking how a topic (a bill, an election, a public health issue) gets covered across outlets |
| **Content aggregators and newsletters** | Curated topic digests pulled straight from predefined sections like Business or Technology |

### 📥 Input parameters

#### Search

| Parameter | Type | Description |
|-----------|------|--------------|
| `keywords` | Array | Keywords or phrases to search. Supports Google search operators: quotes for an exact phrase, `OR`, `-` to exclude a term, and `site:` to restrict to one publisher. |
| `topics` | Array | Predefined Google News topics: World, Nation, Business, Technology, Entertainment, Sports, Science, Health. |
| `topicUrls` | Array | Any Google News topic or section URL, for niche categories not covered by the predefined list. |

At least one of `keywords`, `topics`, or `topicUrls` is required.

#### Filters

| Parameter | Type | Description |
|-----------|------|--------------|
| `timeframe` | Select | How far back to search: last hour, last 24 hours, last 7 days, last 30 days, last year, or all time. Default `7d`. Applies to keyword searches. |
| `regionLanguage` | Select | Region and language pair for results, for example `US:en`, `FR:fr`, or `JP:ja`. 70+ combinations available. Default `US:en`. |

#### Options

| Parameter | Type | Description |
|-----------|------|--------------|
| `maxItems` | Integer | Maximum articles per keyword or topic. Default 50. Set above 100 and the scraper automatically extends the search across additional time windows to keep delivering results. |
| `decodeUrls` | Boolean | Resolve each Google News link to the real article URL on the publisher's site. Default `true`. |
| `enrichArticles` | Boolean | Fetch each article's page to pull its description and preview image. Default `true`. |

### 📊 Output data

Searching `bitcoin` with defaults:

```json
{
    "title": "Bitcoin posts worst month since June 2022 as risk appetite fades",
    "url": "https://finance.yahoo.com/markets/crypto/article/bitcoin-posts-worst-month-since-june-2022-141926609.html",
    "googleNewsUrl": "https://news.google.com/rss/articles/CBMi6gFBVV95cUxOdUtlNzJNVmVlQUhXSTZwaDdMUjNLSDI1UERWTVF6TUlvWUxheUJDNGVCTDEzTGxQOHFzaEZwSGNzTks0SEZaSllNVWhpMC1rWWVEVFlRRlVvVFFnWnVKTFFpVkplcjVKSDNaMHRyYWFzRElqQUVtRGp6d3dybjVxak5MUGwwUS1JMVdYN1lFZzB2RUJrOWZ3RmxYLWZsNnhEa2pPY1NhcktGRFZGY1hPSkdoSTRia29TU0E1NnZZNUVfUHY4M3FuSUp6ZFlQS2hmRmxRRWU0Sm5kRVIzRGNycXJKellZRi1FU2c?oc=5",
    "urlDecoded": true,
    "source": "Yahoo Finance",
    "sourceUrl": "https://finance.yahoo.com",
    "publishedAt": "2026-07-01T08:53:05Z",
    "description": "Bitcoin capped the last day of the month with losses.",
    "image": "https://s.yimg.com/lo/mysterio/api/EE03B4EC638734842D8010DD9CC4588DFD1956F4C694659C02042EA51E2DE870.jpg",
    "query": "bitcoin",
    "position": 2,
    "scrapedAt": "2026-07-04T18:37:12Z"
}
````

Browsing the Technology topic instead of searching a keyword swaps `query` for `topic`:

```json
{
    "title": "Google Wallet finally shows all your spending in one place",
    "url": "https://www.androidpolice.com/google-wallet-finally-shows-all-your-spending-in-one-place/",
    "googleNewsUrl": "https://news.google.com/rss/articles/CBMikwFBVV95cUxNaTZLdzBJN1VxejZhcWFxMkRVdmhwVHRiMWUtQ2tNajhhanhUYjdZVVo1eEpFVUxZb2U0LWY5UU92SEhKMnN5WjdrNHo4dkp1dERkODJsMENaSXBTVXRtb0hSazZVXzZWYXU1ZFltNjByMENpTjJ4aVAxQTZtaWx2LTdEMUpscjJNM0dBOGZ2SGdPT0E?oc=5",
    "urlDecoded": true,
    "source": "Android Police",
    "sourceUrl": "https://www.androidpolice.com",
    "publishedAt": "2026-07-03T21:47:25Z",
    "description": "Purchases made on phones and watches appear together",
    "image": "https://static0.anpoimages.com/wordpress/wp-content/uploads/2026/02/google-wallet-logo-surrounded-by-colorful-floating-digital-cards.png",
    "topic": "TECHNOLOGY",
    "position": 1,
    "scrapedAt": "2026-07-04T18:37:26Z"
}
```

### 🗂️ Data fields

| Category | Fields |
|----------|--------|
| **Article** | `title`, `publishedAt`, `description`, `image`, `position` |
| **Links** | `url` (real publisher URL, present when `urlDecoded` is true), `googleNewsUrl` (the original Google News link), `urlDecoded`, `ampUrl` (the article's AMP version, included when the publisher offers one) |
| **Source** | `source` (publisher name), `sourceUrl` (publisher domain) |
| **Provenance** | `query` (the keyword that returned this article) or `topic` (the topic or section that returned it) |
| **Metadata** | `scrapedAt` |

Structured fields per article. `publishedAt` and `scrapedAt` are both UTC timestamps in ISO 8601 format, ready to sort or filter on directly. `url` is the publisher's own link and does not expire. `description` and `image` come from the publisher's own page metadata: most mainstream outlets publish both, but a share of smaller or paywalled sites omit one or both tags, in which case the field ships as an empty string rather than a missing key, so your schema stays consistent across every row.

### 🚀 Examples

#### Track mentions of a company

```json
{
    "keywords": ["Tesla"],
    "maxItems": 50,
    "timeframe": "7d"
}
```

#### Watch a competitor with an exact phrase and a niche exclusion

```json
{
    "keywords": ["\"supply chain\" -sponsored"],
    "maxItems": 100,
    "timeframe": "30d",
    "regionLanguage": "GB:en"
}
```

#### Pull the daily Business and Technology digest

```json
{
    "topics": ["BUSINESS", "TECHNOLOGY"],
    "maxItems": 30,
    "timeframe": "1d"
}
```

#### Go past 100 results on a broad keyword

```json
{
    "keywords": ["artificial intelligence"],
    "maxItems": 250,
    "timeframe": "30d",
    "regionLanguage": "US:en"
}
```

#### Monitor one publisher for a niche keyword in French

```json
{
    "keywords": ["site:lemonde.fr OR site:lefigaro.fr elections"],
    "maxItems": 60,
    "timeframe": "7d",
    "regionLanguage": "FR:fr"
}
```

#### Fast headline sweep with links and descriptions turned off

```json
{
    "keywords": ["stock market"],
    "maxItems": 20,
    "timeframe": "1d",
    "decodeUrls": false,
    "enrichArticles": false
}
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT, or Cursor to give it full context about this scraper:

```
You have access to the Google News Scraper on Apify: silentflow/google-news-scraper

Input schema:
- keywords (array of strings, default []): keywords to search, supports site:, OR, "exact phrase", -exclude
- topics (array of strings, default []): WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH
- topicUrls (array of strings, default []): custom Google News topic or section URLs
- maxItems (integer, default 50): max articles per keyword or topic; for keyword searches above 100, auto-extends across time windows to break past the single-feed cap
- timeframe (string, default "7d"): 1h, 1d, 7d, 30d, 1y, or all
- regionLanguage (string, default "US:en"): region:language pair, 70+ combinations
- decodeUrls (boolean, default true): resolve real publisher URLs
- enrichArticles (boolean, default true): fetch description and preview image

At least one of keywords, topics, or topicUrls is required.

Output per article:
- title (string)
- url (string, real publisher URL)
- googleNewsUrl (string)
- ampUrl (string, present when the publisher offers an AMP version)
- urlDecoded (boolean)
- source (string)
- sourceUrl (string)
- publishedAt (string, ISO 8601 UTC)
- description (string, may be empty)
- image (string, may be empty)
- query (string, present for keyword searches) or topic (string, present for topic/section runs)
- position (integer)
- scrapedAt (string, RFC3339 UTC)

Pay per result delivered. Use apify-client for Python or JS.
```

### 💻 Integrations

#### Python: feed a brand-monitoring pipeline

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("silentflow/google-news-scraper").call(run_input={
    "keywords": ["Tesla", "SpaceX"],
    "maxItems": 100,
    "timeframe": "1d",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["urlDecoded"]:
        print(f"{item['publishedAt']} | {item['source']}: {item['title']}")
        print(f"  {item['url']}")
```

#### JavaScript: build a daily topic digest

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('silentflow/google-news-scraper').call({
    topics: ['TECHNOLOGY', 'BUSINESS'],
    maxItems: 30,
    timeframe: '1d',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const bySource = {};
items.forEach(item => {
    bySource[item.source] = (bySource[item.source] || 0) + 1;
});
console.log(bySource);
```

#### Export straight to CSV with the Apify CLI

```bash
apify call silentflow/google-news-scraper --input '{
  "keywords": ["climate change"],
  "maxItems": 200,
  "timeframe": "30d"
}'

apify datasets get-items --format csv > google-news-results.csv
```

### 📈 Performance

| Metric | Value |
|--------|-------|
| Articles per feed before time-window extension | ~100 |
| Small run (10 articles, URLs decoded, description and image enriched) | Under 4 seconds |
| Larger run past the 100-article cap (220 articles via automatic time slicing) | ~28 seconds, zero duplicates |
| Fast mode (`decodeUrls` and `enrichArticles` off) | 20 headlines in under 1 second |
| URL decode success rate | Effectively 100% across tested keywords and topics |
| Region and language combinations | 70+ |
| Predefined topics | 8 |
| Fields per article | 12 |

### 💾 Data export

Every run's results are available on the dataset page in JSON, CSV, Excel, HTML table, and RSS formats, downloadable directly from the Apify Console. To pull results programmatically:

```
https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv&token=YOUR_TOKEN
```

Swap `format=csv` for `json`, `xlsx`, `html`, or `rss` depending on what your pipeline needs. The dataset ID is returned by every run and visible on the Console's run overview page.

### 💡 Tips for best results

1. **Leave `decodeUrls` and `enrichArticles` on** unless you only need raw headlines fast. The default already returns real URLs, descriptions, and images, so most users never need to touch these toggles.
2. **Use `site:` to scope a keyword to one or two trusted publishers** when you want signal, not noise, from a broad term like a company name.
3. **Set `maxItems` above 100 for broad, evergreen keywords** like an industry term or a public figure. The automatic time-window extension keeps returning fresh, non-duplicate articles well past the single-feed limit.
4. **Match `regionLanguage` to where the story is actually being covered.** A US-based search on a European election will miss most of the local coverage; switching to the right country and language surfaces it.
5. **Combine multiple keywords in one run** (e.g. a brand name and its main competitors) to build a single comparative dataset instead of running the actor multiple times.
6. **Narrow `timeframe` to `1h` or `1d` for breaking-news monitoring** and widen it to `30d` or `1y` for trend and retrospective research.

### ❓ FAQ

**Q: What exactly does this scraper extract?**
A: Structured articles from Google News: headline, real publisher URL, source, publish date, description, and preview image, one row per article.

**Q: What is Google News, for anyone unfamiliar?**
A: Google's aggregated news feed. It indexes articles from thousands of publishers worldwide and organizes them by keyword search, topic (World, Business, Technology, and so on), and region or language.

**Q: Do the article URLs actually work, or are they Google redirect links?**
A: By default they resolve to the real article on the publisher's own site. The original Google News link is also kept in `googleNewsUrl` in case you want it, and `urlDecoded` tells you whether the resolution succeeded for that row.

**Q: Can I search more than 100 articles for one keyword?**
A: Yes. Set `maxItems` above 100 and the scraper automatically searches additional time windows and merges the results with no duplicates.

**Q: Do I need a Google account or API key?**
A: No. The scraper reads publicly available news feeds. No login, no API key, no cookies.

**Q: Can I run multiple keywords and topics in the same run?**
A: Yes. `keywords`, `topics`, and `topicUrls` can all be set at once; each one is processed and tagged so you know which query or topic returned which article.

**Q: Why are `description` or `image` sometimes empty?**
A: Those two fields come from the publisher's own page metadata. Most mainstream outlets publish both, but some smaller sites or specific article types omit one or both tags. The row still ships with every other field filled in; only `description` and/or `image` come back empty for that article.

**Q: How fresh is the data?**
A: Every run fetches live from Google News at the moment you start it. There is no caching layer, so results reflect what is published right now for your timeframe.

**Q: Can I combine a timeframe filter with a specific region and language?**
A: Yes, filters stack. A `timeframe` of `1d` with `regionLanguage` set to `FR:fr` returns only French-language articles from the last 24 hours, for example.

**Q: Are the article URLs permanent, or do they expire?**
A: The decoded `url` is the publisher's own permanent article link. `googleNewsUrl` and `image` point to third-party infrastructure and can change over time at the publisher's discretion; the same is true of any article you'd bookmark directly from a browser.

### ⚖️ Legal

This Actor extracts publicly available data from Google News and the linked publisher pages. It does not bypass any login, paywall, or CAPTCHA. Users are responsible for complying with Google's and each publisher's terms of service and with applicable data protection laws (GDPR, CCPA, and other regional regulations where relevant). The data returned reflects publicly published news content; verify accuracy independently before using it for regulated or high-stakes decisions.

### 🔗 Related scrapers

Looking for other data sources to pair with news monitoring? Check the full catalog: [silentflow on Apify](https://apify.com/silentflow), including social listening, e-commerce, and job market scrapers that combine well with news-driven research.

### 📬 Support

Need something this scraper doesn't do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing questions? Check the Monetization tab on the actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

Keywords to search for. Supports Google News operators: quotes for exact match, OR, minus to exclude, site: to filter by website.

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

Predefined Google News topics to scrape.

## `topicUrls` (type: `array`):

Google News topic or section URLs for niche categories, for example https://news.google.com/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGx1YlY4U0FtVnVHZ0pWVXlnQVAB

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

Maximum number of articles per keyword or topic. For keyword searches, values above 100 automatically extend across time windows to break past the single-feed cap.

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

How far back to search. Applies to keyword searches.

## `regionLanguage` (type: `string`):

Region and language for the news results.

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

Resolve Google News links to the original article URLs. Enabled by default.

## `enrichArticles` (type: `boolean`):

Fetch each article page to extract its description and preview image. Enabled by default.

## Actor input object example

```json
{
  "keywords": [
    "bitcoin"
  ],
  "maxItems": 50,
  "timeframe": "7d",
  "regionLanguage": "US:en",
  "decodeUrls": true,
  "enrichArticles": true
}
```

# Actor output Schema

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

Scraped news articles with decoded publisher URLs, descriptions, and images.

# 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": [
        "bitcoin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/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 = { "keywords": ["bitcoin"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google News Scraper",
        "description": "Scrape Google News by keyword, topic, or section. Get real publisher article URLs, not Google redirect links, plus descriptions, images, sources, and publish dates. Break past the 100-result limit, cover 70+ countries and languages, and export to JSON, CSV, or Excel for media monitoring and PR.",
        "version": "1.0",
        "x-build-id": "YuCCFfcc0up4QXhSV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~google-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-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/silentflow~google-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-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/silentflow~google-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-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",
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search for. Supports Google News operators: quotes for exact match, OR, minus to exclude, site: to filter by website.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topics": {
                        "title": "News topics",
                        "type": "array",
                        "description": "Predefined Google News topics to scrape.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "WORLD",
                                "NATION",
                                "BUSINESS",
                                "TECHNOLOGY",
                                "ENTERTAINMENT",
                                "SPORTS",
                                "SCIENCE",
                                "HEALTH"
                            ],
                            "enumTitles": [
                                "🌍 World",
                                "🏛️ Nation",
                                "💼 Business",
                                "💻 Technology",
                                "🎬 Entertainment",
                                "⚽ Sports",
                                "🔬 Science",
                                "🏥 Health"
                            ]
                        }
                    },
                    "topicUrls": {
                        "title": "Custom topic or section URLs",
                        "type": "array",
                        "description": "Google News topic or section URLs for niche categories, for example https://news.google.com/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGx1YlY4U0FtVnVHZ0pWVXlnQVAB",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max articles",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of articles per keyword or topic. For keyword searches, values above 100 automatically extend across time windows to break past the single-feed cap.",
                        "default": 50
                    },
                    "timeframe": {
                        "title": "Time period",
                        "enum": [
                            "1h",
                            "1d",
                            "7d",
                            "30d",
                            "1y",
                            "all"
                        ],
                        "type": "string",
                        "description": "How far back to search. Applies to keyword searches.",
                        "default": "7d"
                    },
                    "regionLanguage": {
                        "title": "Region and language",
                        "enum": [
                            "US:en",
                            "GB:en",
                            "AU:en",
                            "CA:en",
                            "IN:en",
                            "IE:en",
                            "NZ:en",
                            "SG:en",
                            "ZA:en",
                            "IL:en",
                            "PH:en",
                            "MY:en",
                            "PK:en",
                            "NG:en",
                            "KE:en",
                            "FR:fr",
                            "BE:fr",
                            "CA:fr",
                            "CH:fr",
                            "MA:fr",
                            "SN:fr",
                            "DE:de",
                            "AT:de",
                            "CH:de",
                            "ES:es",
                            "MX:es-419",
                            "AR:es-419",
                            "CL:es-419",
                            "CO:es-419",
                            "PE:es-419",
                            "VE:es-419",
                            "CU:es-419",
                            "US:es-419",
                            "IT:it",
                            "NL:nl",
                            "BE:nl",
                            "PT:pt-150",
                            "BR:pt-419",
                            "PL:pl",
                            "RO:ro",
                            "HU:hu",
                            "CZ:cs",
                            "SK:sk",
                            "SI:sl",
                            "SE:sv",
                            "NO:no",
                            "LV:lv",
                            "LT:lt",
                            "GR:el",
                            "BG:bg",
                            "RS:sr",
                            "UA:uk",
                            "RU:ru",
                            "TR:tr",
                            "AE:ar",
                            "SA:ar",
                            "EG:ar",
                            "LB:ar",
                            "IL:he",
                            "IN:hi",
                            "IN:mr",
                            "IN:ta",
                            "IN:te",
                            "IN:ml",
                            "IN:bn",
                            "BD:bn",
                            "TH:th",
                            "VN:vi",
                            "ID:id",
                            "JP:ja",
                            "KR:ko",
                            "CN:zh-Hans",
                            "TW:zh-Hant",
                            "HK:zh-Hant"
                        ],
                        "type": "string",
                        "description": "Region and language for the news results.",
                        "default": "US:en"
                    },
                    "decodeUrls": {
                        "title": "Decode article URLs",
                        "type": "boolean",
                        "description": "Resolve Google News links to the original article URLs. Enabled by default.",
                        "default": true
                    },
                    "enrichArticles": {
                        "title": "Extract descriptions and images",
                        "type": "boolean",
                        "description": "Fetch each article page to extract its description and preview image. Enabled by default.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
