Google News RSS vs a Google News API: what you actually get (with working Python)

Google does not offer an official Google News API. If you need news results in code, you end up with one of two options: the undocumented Google News RSS feed, or a third-party API that returns the same kind of data as JSON. Both work. They differ in ways that only show up once you run them for a while.

This post compares them using real runs from 30 October 2026, with Python for each. We sell one of the options (the Siftwright Google News API), so we say plainly where the free RSS feed is the better choice.

The Google News RSS feed

Google News search is available as an RSS feed at a predictable URL:

https://news.google.com/rss/search?q=electric+vehicles&hl=en-US&gl=US&ceid=US:en

q is the query, hl the interface language, gl the country and ceid the country-and-language edition. A plain request returned HTTP 200 and 100 <item> elements in our run. Each item has a title, a link, a GUID, a publication date, an HTML description and a <source> element with the publisher.

Here is a minimal client using only the standard library:

import urllib.parse, urllib.request
import xml.etree.ElementTree as ET
from email.utils import parsedate_to_datetime

def google_news_rss(query, hl="en-US", gl="US", ceid="US:en"):
    url = "https://news.google.com/rss/search?" + urllib.parse.urlencode(
        {"q": query, "hl": hl, "gl": gl, "ceid": ceid})
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
    with urllib.request.urlopen(req, timeout=30) as r:
        root = ET.fromstring(r.read())
    items = []
    for it in root.findall("./channel/item"):
        src = it.find("source")
        items.append({
            "title": it.findtext("title"),
            "link": it.findtext("link"),
            "source": src.text if src is not None else None,
            "published": parsedate_to_datetime(it.findtext("pubDate")).isoformat(),
        })
    return items

for i in google_news_rss("electric vehicles")[:3]:
    print(i["published"], "|", i["source"], "|", i["title"])

Real output:

2026-10-29T21:02:00+00:00 | Electrek | Toyota’s EV sales more than doubled in a year, but gas cars are getting crushed in China - Electrek
2026-10-29T22:00:00+00:00 | The Washington Post | Why Americans can’t buy these world-class EVs - The Washington Post
2026-10-27T16:00:00+00:00 | The Washington Post | Column | I went to Mexico to test-drive the cars Americans can’t buy - The Washington Post

For a hobby project, a personal dashboard or a quick prototype, this is hard to beat: it is free and needs no signup. Other languages work by changing the edition. A search for Elektroautos with hl=de&gl=DE&ceid=DE:de returned 100 German-language items, the first from Spiegel.

What the RSS feed leaves for you to clean up

Running the client above and inspecting the 100 items exposed the following.

The publisher name is glued onto the title. In our run, all 100 titles ended with - <source>, as in ... getting crushed in China - Electrek. If you show or deduplicate titles, you have to strip that suffix yourself.

Every link is a Google redirect. All 100 links were news.google.com/rss/articles/... URLs, not the publisher's address. They open the article in a browser, but if you want the publisher's domain for analysis you need to follow the redirect, or use the <source url> attribute (which gives the publisher's homepage, not the article).

The description is HTML. It contains a link to the article plus related-coverage links, not a text snippet. Parsing it for a summary is fragile.

A hard cap of 100 items. Our test query returned exactly 100, and so did the same query with when:1d and when:7d added. For broad queries, you see the newest slice, not everything. Narrow the query to go deeper.

Parameters are required. Requests without the hl/gl/ceid parameters were answered with a 302 redirect instead of a feed (we did not follow it). Build the URL with all three.

Terms. The feed carries a copyright notice stating it is made available "solely for the purpose of rendering Google News results within a personal feed reader for personal, non-commercial use". Read that before you build a commercial product on it. We are not lawyers and this is not legal advice, but it is the reason many teams look at paid APIs.

No guarantees. It is an undocumented endpoint. Nothing promises it will keep its format, stay unthrottled at volume or stay available.

The same search through a Google News API

A Google News API does the extraction and clean-up for you and returns JSON. The call below uses the public Siftwright Google News Scraper Actor on Apify, which is the same engine behind our API; pay-per-event pricing means you can try it on Apify's free plan credit:

import os, json, urllib.request

def google_news_actor(query, max_items=100, language="en", country="US"):
    url = ("https://api.apify.com/v2/acts/siftwright~google-news-scraper/"
           "run-sync-get-dataset-items?token=" + os.environ["APIFY_TOKEN"])
    body = json.dumps({"query": query, "maxItems": max_items,
                       "language": language, "country": country}).encode()
    req = urllib.request.Request(url, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=120) as r:
        return json.load(r)

for r in google_news_actor("electric vehicles", 5):
    print(r["publishedAt"], "|", r["source"], "|", r["title"][:60], "|", r["status"])

Real output:

2026-10-29T21:02:00.000Z | Electrek | Toyota’s EV sales more than doubled in a year, but gas cars  | ok
2026-10-29T22:00:00.000Z | The Washington Post | Why Americans can’t buy these world-class EVs | ok
2026-10-27T16:00:00.000Z | The Washington Post | Column | I went to Mexico to test-drive the cars Americans c | ok
2026-10-30T06:00:00.000Z | Barron's | ‘This Is a Knife Fight:’ Inside China’s Ruthless EV Blitz Up | ok
2026-10-29T23:02:00.000Z | Reuters | Chinese EVs win over some in South Korea, but Japan is provi | ok

Each record has query, title, link, source, publishedAt (ISO 8601 in UTC), snippet and status. The title comes without the source suffix, and the publisher is its own field. The same query matched the same articles as the RSS feed, which is what you would expect.

To be exact about what is and is not different:

• Links are still Google redirects. The link values in our run were news.google.com/rss/articles/... URLs, same as the feed. The API does not magically resolve them. If you need publisher URLs, you still follow the redirect yourself.
• The cap is the same. Asking for maxItems: 150 returned 100 records.
• The sources are the same. Both read Google News. The API does not give you a different or bigger index.

So the value of an API is not extra data. It is the clean schema, the language and country parameters, an explicit status per item, and a service you call with a key and a price rather than an endpoint you hope keeps working.

Side by side

Which one should you use?

Use the RSS feed when:

• you are prototyping, learning or building something for yourself;
• you run a handful of queries and do not mind writing the clean-up code above;
• you are comfortable with the feed's notice and its lack of guarantees.

Use an API when:

• the data feeds something a customer pays for, and you need a clear, supported source;
• you run many queries and want a consistent schema without maintaining parsing code;
• you want to know what each item cost and why an item failed.

In either case, store the results and deduplicate them rather than re-reading the same feed. The pipeline in our news monitoring guide shows queries, dedupe, SQLite storage and a daily digest, and the same code works with either source if you map the fields to title, link, source and published.

Adapting the RSS client to the same schema

If you start with RSS and might switch later, normalise now. A small adapter makes the switch a one-line change:

import re

def normalise_rss(item):
    title = item["title"]
    if item["source"] and title.endswith(" - " + item["source"]):
        title = title[: -len(item["source"]) - 3]
    return {"title": title, "link": item["link"],
            "source": item["source"], "published": item["published"]}

def normalise_api(row):
    return {"title": row["title"], "link": row["link"],
            "source": row["source"], "published": row["publishedAt"]}

Every downstream step (dedupe, storage, alerts) then works on one shape. For deduplication, key on the normalised title plus source rather than the link, since a story syndicated to several outlets has several links but the same headline.

What it costs

On our plans, a result is one article that came back with status ok, and empty searches are free. Plans start at $29 per month with 10,000 successful results (see pricing). If you prefer no subscription, the Apify Actor charges $1.50 per 1,000 articles. For the 100-article test above, that is $0.15. A quick comparison for your own volume is on the pricing calculator, and our Google News API page has a live demo with no signup.

A note on testing: the RSS code and the Actor call above were run on 30 October 2026 exactly as shown. We did not re-run the /v1/google-news REST endpoint with a fresh key for this post, since the Actor returns the same record shape, and the fields in the API's response are listed in the docs.

Summary

• Google has no official News API. The RSS feed is free and decent for personal projects, but it returns XML with the publisher glued to the title, HTML descriptions and Google redirect links, and its own notice limits it to personal, non-commercial use.
• A News API returns the same articles with a clean schema, ISO dates, a separate source field and per-item status. It does not give you a larger index or publisher links.
• Whichever you pick, normalise to one schema early, deduplicate on title plus source, and keep your queries narrow, because both stop at 100 items.

Questions or a case this post missed? Email support@siftwright.com.