How to Scrape Google News in 2026 (for Free!)

If you want to monitor the news — your brand, a competitor, a topic — Google News is the obvious source and, happily, the one place in this series with a genuinely free, no-browser route hiding in plain sight: RSS.

Most people skip it, fire up a headless browser against the JavaScript-heavy news.google.com site, and burn hours fighting redirect-encoded article URLs. There is a much easier path for headline monitoring, and a couple of harder ones for when you need more.

This guide covers all three free routes, shows you how to decode the article links, set freshness and locale, and poll without getting blocked — with working Python throughout.

The three free routes

There are three ways to pull Google News without paying, and the order people try them is almost exactly backwards from the order they should.

For 90% of monitoring needs, RSS is all you need and it is the gentlest on everyone — including Google's servers. Reach for the browser only when you specifically need the visual SERP layout or features RSS does not carry.

Route 1: the Google News RSS feed

Google News publishes RSS feeds for both search queries and topics. They return clean XML, need no API key, and parse in a handful of lines with feedparser:

# pip install feedparser
import feedparser
from urllib.parse import quote

def google_news_rss(query, hl="en-US", gl="US", ceid="US:en"):
    url = (
        f"https://news.google.com/rss/search?q={quote(query)}"
        f"&hl={hl}&gl={gl}&ceid={ceid}"
    )
    feed = feedparser.parse(url)
    items = []
    for e in feed.entries:
        items.append({
            "title": e.title,
            "link": e.link,                       # Google News redirect URL
            "published": e.get("published"),
            "source": e.source.title if "source" in e else None,
        })
    return items

for item in google_news_rss("electric vehicles")[:10]:
    print(item["published"], "-", item["title"])

That is a working news monitor in twelve lines, no browser, no proxy. For a topic feed instead of a search — say, all Technology headlines — swap the path to news.google.com/rss/headlines/section/topic/TECHNOLOGY with the same locale parameters.

Decoding the article URLs

Run the code and every link points at news.google.com, not the publisher. Google routes clicks through an encoded redirect so it can log them. For years you could base64-decode that token to recover the real URL — then in 2024 Google changed the encoding and that trick stopped working.

The reliable method now is to simply follow the redirect with an HTTP request and read the final URL:

import requests

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
        "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
    )
}

def resolve_article_url(google_news_url, timeout=15):
    """Follow the Google News redirect to the publisher's real URL."""
    try:
        resp = requests.get(
            google_news_url, headers=HEADERS,
            allow_redirects=True, timeout=timeout,
        )
        return resp.url
    except requests.RequestException:
        return google_news_url      # fall back to the wrapper

real = resolve_article_url(google_news_rss("electric vehicles")[0]["link"])
print(real)

Following the redirect works for most articles. A minority of the newer encoded links resolve only after a JavaScript step, in which case a headless browser or a maintained decoder library handles them — but resolve lazily, only for the articles you actually open, so you are not making a redirect request per headline.

Freshness and locale parameters

Three query parameters control what region and language you get, and getting them right is the difference between US tech news and, say, German business news.

Keep gl and ceid consistent — mismatched values quietly return a different edition than you expect. For freshness within a query, append a time qualifier like when:1d or when:1h directly to the search string (for example q=electric+vehicles+when:1d) to limit results to the last day or hour.

Route 2: the news SERP with a browser

When you need the visual news results page rather than a feed — clustered stories, thumbnails, the source carousel — you scrape the news SERP. The simplest entry is Google web search's News tab via tbm=nws, which is lighter than the full news.google.com app:

const puppeteer = require('puppeteer-extra');
const Stealth = require('puppeteer-extra-plugin-stealth');
puppeteer.use(Stealth());

(async () => {
  const browser = await puppeteer.launch({
    headless: 'new',
    args: ['--no-sandbox', '--disable-blink-features=AutomationControlled'],
  });
  const page = await browser.newPage();
  await page.setCookie({ name: 'CONSENT', value: 'YES+', domain: '.google.com' });

  const q = 'electric vehicles';
  await page.goto(
    `https://www.google.com/search?q=${encodeURIComponent(q)}&tbm=nws&hl=en&gl=us`,
    { waitUntil: 'domcontentloaded', timeout: 30000 }
  );

  const news = await page.$$eval('a[href^="http"]', (links) =>
    links
      .filter((a) => a.querySelector('div[role="heading"], h3'))
      .map((a) => ({
        title: (a.querySelector('div[role="heading"], h3') || {}).innerText,
        url: a.href,
      }))
  );

  console.log(news.slice(0, 10));
  await browser.close();
})();

This is the same headless approach from scraping Google for free, pointed at the news tab. It is heavier and more block-prone than RSS, so use it only when the feed genuinely lacks what you need, and apply the same bandwidth discipline from cutting scraping bandwidth.

De-duping and polling cadence

News monitoring is a long-running poll, not a one-shot scrape, so two habits keep it clean and unblocked. De-duplicate by a stable key — the resolved article URL, or a normalized title plus source — so the same story across two polls is counted once. And pace the polling: every few minutes per query is plenty to feel real-time without hammering the feed.

seen = set()

def poll_once(query):
    fresh = []
    for item in google_news_rss(query):
        key = item["link"]
        if key not in seen:
            seen.add(key)
            fresh.append(item)
    return fresh            # only stories you haven't seen before

That de-dupe set is the backbone of any alerting system — new items in, alert out. For the bigger picture of building this into brand and PR monitoring, see PR and media monitoring with a SERP API and real-time search monitoring for brand protection.

The structured alternative

RSS is excellent for headlines, but it gives you titles and links, not a consistent, parsed, de-duplicated news object with the publisher URL already resolved. When you want that — especially across many queries and regions — a news API hands it over directly:

import requests

resp = requests.get(
    "https://api.apiserpent.com/api/news",
    headers={"X-API-Key": "sk_live_your_key"},
    params={"q": "electric vehicles", "country": "us", "language": "en"},
)

for article in resp.json()["results"]["news"]:
    print(article["date"], article["source"], "-", article["title"])
    print("  ", article["url"])     # already resolved

It is the same account and JSON shape as the search endpoints, so a project that mixes news monitoring with web search uses one key. Compare the build-vs-buy trade-offs in our news API guide for developers, or try a query in the playground.

FAQ

Is the Google News RSS feed free to use?

Yes. Google News exposes RSS feeds for search queries and topics that return clean XML with no JavaScript and no API key, and you can parse them with a library like feedparser in a few lines. It is the single best free route for headline monitoring. Google does not guarantee it forever, so build a fallback, but today it is genuinely free.

Why are Google News article URLs encoded?

Google News links point at a news.google.com redirect that carries an encoded token instead of the publisher URL, so it can log the click and route the reader. In 2024 Google changed this encoding, which broke the old base64 decoding trick. The reliable way to get the real article URL now is to follow the redirect with an HTTP request, or use a maintained decoder.

How fresh is scraped Google News data?

Very fresh. The RSS feeds update within minutes of publication, so for brand monitoring or PR alerts you can poll every few minutes and catch stories quickly. Be polite about cadence — once every few minutes per query is plenty — and de-duplicate by article URL so the same story is not counted twice across polls.

Can I scrape Google News without a browser?

Yes, via the RSS feeds, which need no JavaScript at all. The full news.google.com site and the Google news SERP are JavaScript-heavy and need a headless browser, but for most monitoring use cases the RSS route gives you titles, sources, and timestamps without one.