Google News Scraper

Google News Scraper — Headlines, Publisher Domain and Links

Google News Scraper Input turns a Google News search into structured JSON: headline, publisher name, real publisher domain, publish timestamp, article ID and the article's Google News link — no login, API key or proxy required. Point it at a query and it reads the same public RSS feed Google News itself is built on, so results match what a visitor sees right now, across 245 country and 135 language editions. The feed returns roughly 100 articles per query and has no pagination — set maxItems above that and you get everything the feed has, not more. It's built for media monitoring teams, content curators, market researchers and AI pipelines that need a clean, current news feed rather than a scraped webpage.

What is Google News Scraper Input?

Google News Scraper Input is an Apify Actor that queries the public Google News RSS search feed (news.google.com/rss/search) and returns each result as a typed dataset row. No Google account, cookie or API key is used anywhere in the run — the feed is public and keyless, and the Actor reads it directly over HTTP.

• Search by free-text keyword, with full support for Google's own query operators — "exact phrase", intitle:, -excluded, OR, site:example.com, when:12h, after:/before: dates
• Country and language editions via gl and hl — 245 countries, 135 languages, each one changing the actual result set returned
• Time filters wired to the query operators that genuinely work on this feed: last hour, last 24 hours, last 7 days, last 30 days, last year, or a custom after:/before: date range
• The real publisher domain and homepage URL, read straight from the feed's own <source url="..."> element rather than guessed from the redirect link
• Duplicate articles — by Google's own article guid — are dropped once per run before anything is pushed
• Export as JSON, JSONL, CSV, Excel or HTML table straight from the Apify Console, or pull the dataset through the Apify API for a scheduled pipeline

⚠️ The real ceiling: about 100 articles per query, no pagination

This is the one constraint that matters more than any input field, so it's stated here rather than buried in a parameter description.

The Google News RSS search feed returns roughly 99–107 <item> elements per query and has no pagination on this surface — &num=, &start=, &count= and &scoring= are all accepted by the endpoint and silently ignored; six live test queries all landed in that 99–107 band. Setting maxItems to 500 or 50,000 does not fetch more pages, it just caps how much of the same ~100-item feed gets pushed, and the Actor logs a warning whenever your maxItems exceeds the real ceiling. The schema's maximum of 50000 is kept only for backward compatibility with saved task inputs, and you are only ever charged for rows actually pushed — never for the gap between what you asked for and what the feed had. As observed on the lhotanova/google-news-scraper Apify Store listing on 2026-07-26, that Actor documents fetching "day by day" once maxItems exceeds 100 to accumulate more results across multiple date-sharded requests; this base Actor's single-feed-request surface does not perform that sharding. If you need more than ~100 articles for one topic, the only lever here is narrowing the query itself — a more specific keyword, an added site: operator, or a tighter when:/after:/before: window — rather than raising maxItems.

What data can I extract with Google News Scraper Input?

Every article is one dataset row built directly from the feed's own XML fields — no field is inferred, guessed, or fabricated from a second HTTP request.

Field	Description
position	1-based rank of the article in this run's result set, renumbered after any date-window filtering
block_position	Mirrors position on this surface — the feed has no block/cluster grouping, so the two always match
query	The search term you sent, unchanged (not the operator-augmented string actually sent to Google)
title	Headline, with a trailing " - PublisherName" suffix stripped when the feed duplicates it there
source	Publisher display name, exactly as the feed reports it
domain	Real publisher domain, read from the feed's <source url="..."> attribute, never parsed from link
sourceUrl	Publisher's homepage URL, from that same <source url="..."> attribute
link	The Google News article link (news.google.com/rss/articles/...) — an interstitial redirect, not the publisher's article URL directly
guid	Google's own article ID, used internally to drop duplicates within a run
publishedAt	Raw RSS pubDate string, exactly as the feed sent it
date_utc	publishedAt parsed into ISO-8601 UTC, or null if the feed's date string didn't parse — never invented
date	Human relative age at fetch time, e.g. "3 hours ago"
snippet	Cleaned RSS description text, capped at 300 characters

When a run produces zero articles, the Actor pushes a separate, differently-shaped uncharged accounting row instead of a normal article row — see the Output section below.

Headline and content fields

title, snippet and guid are what the article actually is. One honest note on snippet: it is not an independent article summary. Google's RSS <description> for a normal item is just <a>headline</a><font>Publisher</font>, so the cleaned text mostly repeats title and source; on a small share of items it's instead a list of related headlines rather than body text. Treat it as a raw feed field to display next to the headline, not as editorial copy or an AI-generated summary.

Publisher and timing fields

source, domain and sourceUrl identify who published the article — domain is the field to group or filter on for a per-publisher breakdown of coverage. publishedAt, date_utc and date are three views of the same timestamp: date_utc is the one to sort or bucket on programmatically, date is the human-readable one to display in a dashboard, and publishedAt is the raw string kept for audit or debugging.

Search and ranking fields

query, position and block_position are what you filter and segment a multi-query run on. query lets you split one dataset back into per-brand or per-topic slices after running several searches in the same job. position reflects Google's own relevance ranking for that query at fetch time — it is not stable across runs, since Google News re-ranks live, so treat it as a snapshot ordering rather than a persistent article rank.

Why not build this yourself?

Google discontinued its public Google News API years ago and has no current public news-search API that returns arbitrary keyword results the way this feed does, so the realistic alternative is scraping the RSS feed directly — and the maintenance load there is the actual cost of doing it yourself.

The feed's article links (news.google.com/rss/articles/CBMi...) are Google's own obfuscated redirect tokens, not the publisher's URL — getting the real publisher domain means reading the feed's separate <source url="..."> attribute correctly rather than parsing link, which always resolves to news.google.com. Pagination parameters look like they should work (&num=, &start=, &count=, &scoring=) but are silently ignored, and several of the documented tbs= time filters (qdr:, cdr:) are dead too — only the when:/after:/before: query operators actually filter results, and even those leak a handful of out-of-window rows that have to be dropped after the fact. Date-range shortcuts like "last week" or "last month" also can't use week/month tbs units directly — testing showed when:1w and when:1m return an empty feed — so they have to be built from day-based operators instead (when:7d, when:30d). None of this is documented by Google; it has to be found by testing the live feed. Google News Scraper Input has already done that testing and wires the working paths for you, so a run returns clean data on the first try instead of after a week of trial and error against an undocumented endpoint.

Building this from scratch also means owning the parts that are easy to get subtly wrong rather than obviously broken: a proxy ladder that escalates only on a genuine block rather than a false-positive "sorry"/CAPTCHA substring match, a duplicate filter keyed on Google's own article guid rather than a fragile title comparison, and an uncharged accounting row for a zero-result run so an empty dataset doesn't look like a silent failure. A news-search API request is the same feed request either way — the difference is whether the edge cases were found by someone else first.

How to use data extracted from Google News

Media monitoring and PR teams

Track brand, executive or product mentions by running one query per name — "Acme Corp" OR "Acme Inc" — on a recurring Apify schedule rather than a one-off run. Filter the resulting rows on source/domain to see which publishers are covering a story, and read date_utc to see how fast coverage spread from the first mention. Because duplicate guid values are dropped automatically, a daily schedule against the same query returns only genuinely new articles each run rather than a re-pushed backlog.

Agencies auditing coverage for multiple clients

Run the Actor once per client brand name inside the same job, tagging each call with the query value so the combined dataset can be split back apart by client afterward. domain becomes the field to build a per-client publisher-reach table from — how many distinct outlets picked up each brand's news over the reporting period — without maintaining a separate scraper per client. Because each client's slice is identified by its own query value rather than a separate dataset, one recurring Apify schedule can cover an entire client roster, and a new client is added simply by appending one more query to the next run rather than standing up new infrastructure.

Market research and competitive intelligence

Run the same query across several gl/hl editions — say United States/English, United Kingdom/English and Germany/German — to compare how a story or product launch is reported in different markets. Group the combined rows by domain and gl to build a coverage map showing which regions and outlets picked up a story first, using date_utc to line up the timeline across editions.

AI agents and automated pipelines

Feed live news context into an agent by querying a topic on a schedule and passing title, snippet and source into a retrieval pipeline, so a chatbot or summarizer answers with current headlines instead of a stale training cutoff. Because the Actor is a standard HTTP-callable Apify Actor, any agent framework that can make a request can trigger a run and read the dataset back as typed JSON with no HTML parsing step, without needing to teach the agent how to decode Google's own RSS redirect scheme first.

How does Google News Scraper Input compare to other listings?

Checked against the Apify Store's own catalogue snapshot dated 2026-07-08 — user counts, run counts and ratings as captured on that date, not live figures:

Actor	Users	Runs	Rating	Pricing model
lhotanova/google-news-scraper	3117	3,487,653	4.65	Flat monthly price
easyapi/google-news-scraper	2029	328,406	3.85	Pay per event
data_xplorer/google-news-scraper-fast	1290	177,244	4.83	Pay per event

Google News Scraper Input itself bills per article pushed to the dataset (row_result, a pay-per-event charge), matching the pay-per-event model of two of the three listings above rather than a flat monthly subscription — you pay for rows you actually receive, including zero on a run that finds nothing, since the accounting row pushed in that case is explicitly uncharged.

⬇️ Input

Parameter	Required	Type	Description	Example Value
maxItems	✅ Yes	integer	Maximum number of articles to push (you're only charged for rows actually pushed). Minimum 1, maximum 50000, default 10. The feed itself caps at roughly 100 items with no pagination — see the limitation above.	50
query	✅ Yes	string	The search term sent to Google News. Standard Google operators work: "exact phrase", intitle:, -excluded, OR, site:example.com, when:12h, after:2026-01-01, before:2026-02-01. Default "Elon Musk".	"Tesla recall"
gl	No	string	Country edition of Google News (sets gl + ceid). Works — it changes the result set. Enum of 245 countries; no default in the schema. If omitted, the Actor runs as "United States". Unrecognised names fall back to United States and log a warning.	"United Kingdom"
hl	No	string	UI/content language of the Google News edition (sets hl + ceid). Works — it changes the result set. Enum of 135 languages; no default in the schema. If omitted, the Actor runs as "English". Unrecognised names fall back to English and log a warning.	"French"
lr	No	string	Result Language (no effect on this surface). Accepted but has no effect — the feed ignores &lr=; a live A/B test returned an identical feed. Kept so existing saved inputs keep validating; the run log warns when it's set. Use hl instead. Enum of 43 languages.	"Spanish"
cr	No	string	Result Country (no effect on this surface). Accepted but has no effect — the feed ignores &cr=; a live A/B test returned an identical feed. Kept for input compatibility; the run log warns when it's set. Use gl instead. Same 245-country enum as gl.	"Germany"
time_period	No	string	Time filter, wired to the query operators that actually work on this surface. Enum: last_hour (when:1h), last_day (when:1d), last_week (when:7d), last_month (when:30d), last_year (when:1y), custom (after:/before: built from the two fields below). No schema default — if omitted, no time operator is added and the feed's unfiltered ranking is returned.	"last_week"
time_period_min	No	string	Start date of the custom range, MM/DD/YYYY. Used only when time_period is custom; sent as after:YYYY-MM-DD. Must match pattern ^\d{2}/\d{2}/\d{4}$.	"06/01/2026"
time_period_max	No	string	End date of the custom range, MM/DD/YYYY. Used only when time_period is custom; sent as before:YYYY-MM-DD. Must match pattern ^\d{2}/\d{2}/\d{4}$.	"07/01/2026"
nfpr	No	integer	No Autocorrect (no effect on this surface). Accepted but has no effect — &nfpr=1 returns an identical feed. Minimum 0, maximum 1, default 0.	0
filter	No	integer	Similar/Omitted Filter (no effect on this surface). Accepted but has no effect — &filter=0/1 returns an identical feed. Minimum 0, maximum 1, default 1.	1
proxyConfiguration	No	object	Optional. The feed needs no proxy — verified direct from an Apify container. Prefilled as {"useApifyProxy": false}. If a request is blocked, the Actor escalates on its own regardless of this setting: your setting (or no proxy) → Apify datacenter proxy group → Apify residential proxy group. Not a credential field — no API key or token is collected here.	{"useApifyProxy": false}

Example input

{
  "maxItems": 50,
  "query": "Tesla recall",
  "gl": "United Kingdom",
  "hl": "English",
  "time_period": "last_week",
  "proxyConfiguration": { "useApifyProxy": false }
}

Common pitfall: setting time_period to custom but only filling in one of time_period_min / time_period_max. Both are required together — if either is missing or doesn't parse as MM/DD/YYYY, the Actor logs a warning and runs the query with no date filter at all, silently returning the unfiltered feed rather than failing the run. A second, subtler pitfall: gl and hl carry no default in the input schema itself, so a saved task that explicitly sets them to an empty string runs as "United States"/"English" rather than erroring.

⬆️ Output

Typed JSON, one row per article, pushed live as the feed is parsed — no batching delay. Export as JSON, JSONL, CSV, Excel or HTML table directly from the Apify Console's Storage tab, or read the dataset through the Apify API.

Example output

{
  "position": 1,
  "block_position": 1,
  "query": "Tesla recall",
  "title": "Tesla recalls thousands of Cybertrucks over accelerator pedal defect",
  "source": "Reuters",
  "domain": "www.reuters.com",
  "sourceUrl": "https://www.reuters.com",
  "link": "https://news.google.com/rss/articles/CBMib0FVX3lxTFB4eGFtcGxlZGVtb2xpbmtleGFtcGxl0gEA?oc=5",
  "guid": "CBMib0FVX3lxTFB4eGFtcGxlZGVtb2xpbmtleGFtcGxl0gEA",
  "publishedAt": "Fri, 18 Apr 2026 14:32:00 GMT",
  "date_utc": "2026-04-18T14:32:00Z",
  "date": "3 months ago",
  "snippet": "Tesla recalls thousands of Cybertrucks over accelerator pedal defect Reuters"
}

When a query returns nothing

If every proxy rung fails to return a parseable feed, or the feed returns zero <item> elements, or a custom date window drops every row the feed did return, the Actor pushes one uncharged accounting row instead of a normal article row, so an empty run is still visible in your dataset without being billed for it:

{
  "query": "asjdklqweoiuzxcvmnbqwer",
  "errorReason": "no_feed_items",
  "errorMessage": "Every proxy rung failed to return a parseable feed with <item> elements (last reason: xml_without_items). This is either a block or a query with zero Google News results.",
  "itemsReturned": 0
}

errorReason is one of missing_query (no search term supplied), no_feed_items (every proxy rung failed to return a usable feed — covering both a real block and a genuinely zero-result query) or no_rows_after_filter (the feed returned items, but none survived the time_period window). This row has a different shape from a normal article row — it carries errorReason, errorMessage and itemsReturned instead of title/link/domain. errorMessage and itemsReturned are written to every accounting row but are not included in the default dataset view's columns — they're still present if you download the full JSON or read the dataset through the API. Filter clean article rows from accounting rows with if not row.get("errorReason").

A note on redirect links and charging: this Actor never attempts to resolve the news.google.com/rss/articles/... link into the publisher's real article URL — that decoding step, and the extra request per row it requires, belongs to a separate, specialised variant of this Actor. Because no resolution is ever attempted here, there is no failure path where an unresolved redirect gets pushed and charged in place of a real value — link is always the feed's own redirect URL, by design, not a fallback for a failed lookup, and the real destination is instead identified through the separate domain/sourceUrl fields read directly from the feed's <source url="..."> attribute.

How do you filter and target specific articles?

Four real levers control what you get back — everything else in the input schema is either display formatting or a documented no-op kept for input compatibility.

Query operators are the sharpest tool. A bare keyword like "Tesla" returns Google's own relevance ranking; adding site:reuters.com, intitle:"recall", an exact phrase in quotes, OR, or -excluded narrows the same ~100-item feed to what you actually want, since there's no second filtering pass after the fact — precision has to happen in the query itself. These are the same operators named directly in the query parameter's own schema description:

Operator	Example	Narrows to
"exact phrase"	"stock buyback"	Articles containing that exact phrase, not just the individual words
intitle:	intitle:recall	Articles with the term in the headline specifically
-excluded	Tesla -Musk	Drops articles also matching the excluded term
OR	Tesla OR Rivian	Either term, combined into one query and one feed request
site:	site:reuters.com	Only articles the feed attributes to that domain
when:	when:12h	A rolling window, independent of the time_period input
after: / before:	after:2026-01-01	An explicit date boundary — what time_period: "custom" builds for you automatically

Country and language edition — gl and hl — genuinely change the result set: they pick a different regional/language edition of Google News, not just a display language. cr and lr look like they do the same job but don't; a live test confirmed both return a byte-identical feed regardless of value, so use gl/hl for that job instead.

Time window — time_period maps to the query operators that actually filter this feed (when:1h/1d/7d/30d/1y), or custom with time_period_min/time_period_max for an explicit after:/before: range. Rows the feed leaks outside a custom window are dropped after the fact rather than shipped as if the filter had fully worked.

Volume — maxItems caps how many of the feed's ~100 items get pushed; it can't pull more than the feed physically has for that query.

{ "maxItems": 30, "query": "\"AI regulation\" site:reuters.com -opinion" }

{ "maxItems": 50, "query": "F1 Silverstone", "gl": "United Kingdom", "hl": "English" }

{ "maxItems": 100, "query": "flood warning", "time_period": "custom", "time_period_min": "06/01/2026", "time_period_max": "07/01/2026" }

🔗 Related scrapers

Scraper Name	What it extracts
Google Search Autocomplete API	Google's autocomplete suggestions for a seed query
Quora Search Scraper — Fresh Trending Question Monitor	Trending question results from Quora search
Twitter Trends Scraper by City & Multiple Countries	Trending topics by city and country
YouTube Search Scraper — Channel Contact Links	Video search results with channel contact data
Ahrefs Scraper Competitor Comparison	SEO authority and traffic metrics for competitor domains
Moz SEO Health Scorer	Domain and page authority metrics from Moz

How to extract Google News data programmatically

Google News Scraper Input is a standard Apify Actor — one API call, your Apify token as auth, structured JSON back. It runs on the Apify platform only: start it from the Apify Console, call it with the apify-client SDK, or trigger it on a recurring Apify schedule for ongoing monitoring.

Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/google-news-scraper").call(run_input={
    "maxItems": 50,
    "query": "Tesla recall",
    "gl": "United Kingdom",
    "hl": "English",
    "time_period": "last_week",
})

for article in client.dataset(run["defaultDatasetId"]).iterate_items():
    if article.get("errorReason"):
        continue
    print(article["title"], article["domain"], article["date_utc"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request against the Apify API.

Export to spreadsheets or CRM

Download the dataset as CSV directly from the Apify Console's Storage tab, or pull it through the API. title, source, domain, date_utc and link map cleanly onto a headline/publisher/date/link spreadsheet or a media-monitoring CRM import without any transformation. For recurring monitoring, an Apify schedule can trigger the same run daily and a webhook can notify your pipeline the moment each run's dataset is ready.

Is it legal to scrape Google News?

Yes. Google News Scraper Input reads a public RSS feed that requires no login, and every field it returns — headline, publisher name, publisher domain, timestamp, article link — is public news-article metadata, not personal data about an individual.

These are business and content records rather than personal data, so the personal-data regimes that govern profile or reviewer scraping (GDPR/CCPA) don't attach to this output the way they would to a scraper of individual people. What applies instead is Google's own terms of service and any database or unfair-competition rules covering systematic reuse of a compiled feed.

Consult legal counsel for commercial applications involving bulk storage or republication of scraped news content.

❓ FAQ

What happens if my query returns zero articles?

The Actor pushes one uncharged accounting row instead of a normal article row — errorReason will be "missing_query", "no_feed_items" (every proxy rung failed to return a feed with <item> elements, which covers both a real block and a genuinely zero-result query), or "no_rows_after_filter" (the feed had items, but none survived your time_period window). Either way you are not charged for that run.

How many articles can I get per run?

Set maxItems from 1 up to 50000, but the feed itself returns roughly 99–107 items per query with no pagination, so values above ~100 don't return more — see the limitation section above. You're only charged for rows actually pushed, never for the unmet portion of maxItems.

Can I get the real publisher domain along with the headline?

Yes. domain and sourceUrl are read from the feed's own <source url="..."> attribute on every item, not guessed from link (which always points at news.google.com). There is no pagination or volume caveat on these two fields specifically — they're present on the same rows the article text is.

Do gl and hl actually change the results?

Yes, both do — they select a real regional/language edition of Google News. cr, lr, nfpr and filter are also accepted by the input schema but a live test confirmed each one returns a byte-identical feed regardless of value; they're kept only so older saved task inputs keep validating, and the run log warns whenever one is set.

How does the custom date range work?

Set time_period to custom and fill in both time_period_min and time_period_max as MM/DD/YYYY. They're sent to Google as after:/before: operators, which is the one date mechanism that actually filters this feed — the older tbs= parameter some builds send does nothing. Any row the feed leaks outside your window is dropped before the dataset is written, and the drop count is logged.

How accurate are the publish timestamps?

date_utc is parsed directly from the feed's own pubDate field and set to null only if that string doesn't parse — no timestamp is ever invented. date is a relative age computed at fetch time, so it will read differently if you re-run the same query later against the same article.

Does Google News Scraper Input return article thumbnail images?

No, by design. The RSS feed itself carries no image data at all — a live check found 0 of 99 sampled items carrying media:content, media:thumbnail or enclosure. As observed on the easyapi/google-news-scraper listing on 2026-07-26, that Actor's sample output includes a thumbnail field with a large embedded base64 image, obtained by opening each article's Google News redirect page separately and reading its generic preview image — roughly doubling the requests per row for a field the underlying feed doesn't actually provide.

What if Google blocks the request?

The Actor walks a proxy ladder automatically: your own proxyConfiguration setting (or no proxy at all, which is normally sufficient), then an Apify datacenter proxy group, then an Apify residential proxy group, retrying up to twice per rung before escalating. Only a genuinely unusable response — not a plain "sorry" or CAPTCHA substring, which is a documented false-positive generator on modern Google responses — triggers escalation; a response only counts as good if it parses as XML and contains at least one <item>.

How does Google News Scraper Input compare to other Google News scrapers?

Checked on the Apify Store on 2026-07-26: lhotanova/google-news-scraper documents topic-based and hashed-topic search plus a day-by-day date-sharding technique to exceed the ~100-result feed ceiling, which this Actor's base query surface does not perform. easyapi/google-news-scraper documents a "100–5000 results per run" input range and a per-row thumbnail image, neither of which matches how the underlying RSS feed actually behaves. data_xplorer/google-news-scraper-fast's public README is the generic, unedited Apify JavaScript scraping template rather than Google News–specific documentation. This Actor's difference is documenting the feed's real behavior plainly — the ~100-item ceiling, exactly which inputs actually work, and an uncharged accounting row when a run finds nothing — rather than presenting the feed as if it had no limits.

Does Google News Scraper Input work with Claude, ChatGPT and other AI agent frameworks?

Yes. It's callable as a standard HTTP endpoint through the Apify API, so any agent framework that can make a request — LangChain, CrewAI, n8n, or a hand-written tool definition — can invoke it and get typed JSON back with no HTML parsing step.

Can I use it without a Google account or API key?

Yes. The feed is public and keyless, and no proxy is required either — the only credential you need to supply is your own Apify token to run the Actor and read its dataset back through the API.

Are duplicate articles removed?

Yes, within a single run. Each article's Google-assigned guid is tracked as items are parsed, and a repeat guid in the same feed response is skipped before the row is built, so a query that surfaces the same story from two related listings only produces one row.

Does this Actor decode the Google News redirect link into the publisher's real article URL?

No, and this is by design rather than an unhandled edge case. The link field is always the feed's own news.google.com/rss/articles/... redirect token — the Actor never fetches that interstitial to follow it through to the publisher's actual article page, and it never substitutes an unresolved redirect in place of a real value on any row. The real publisher identity is instead carried by domain and sourceUrl, read directly from the feed's own <source url="..."> attribute — a value the feed provides upfront on every item, with no second request and no failure path to charge for. Decoding the redirect token itself into the destination page URL belongs to a separate, specialised variant of this Actor built for that job.

Can I track a specific publisher's coverage of a topic?

Yes, with the site: query operator — for example query: "layoffs" site:techcrunch.com returns only matching articles the feed attributes to that domain. Cross-check the result against the domain field on each returned row, since site: narrows what Google searches for but domain is still the authoritative, feed-supplied value to filter or verify on afterward.

Conclusion

Google News Scraper Input turns the Google News RSS search feed into a clean, typed dataset — headline, publisher, real publisher domain, timestamp and link, with the feed's real ~100-item ceiling documented rather than hidden. It's built for media monitoring, content curation, research and AI pipelines that need current news metadata without scraping a rendered page or maintaining a redirect-decoding pipeline of their own. Open it on the Apify Store, set a query, and click Start.