Google News API: What Exists in 2026 and What to Use Instead

If you are here after Googling “Google News API,” here is the blunt version. There is no official Google News API, and there hasn’t been one for years.

Google retired its News API back in 2011. That retirement was part of a broader shutdown of search-related Google APIs. Google has never shipped a Google News API replacement.

There is no key to request. There is no documentation to read. And there is no google.com endpoint that hands you news.google.com results as JSON.

That leaves a lot of developers stuck, because the need is real. Brand monitoring, PR tracking, competitive press coverage, finance signals, and LLM grounding all want programmatic access to what Google News surfaces. So the Google News API question is really a question about alternatives.

This guide maps what you can genuinely get in 2026: RSS, unofficial libraries, Custom Search, and a News-capable scraping API. It answers the four things everyone lands here for.

What is the alternative? Where are the docs? What does it cost? And is any of it free?

We also ran an original freshness study on the Google News SERP. It sampled 48 queries, roughly 8 hours apart. The results show why cached and RSS-only approaches quietly fall behind. A Python-first tutorial then walks through pulling structured, localized results from a Google News API alternative.

The reality check: what happened to the Google News API

The Google News API was one of several search APIs Google deprecated and shut down around 2011. It was never re-launched. This is the same pattern you see with other retired search products.

Read our writeup on the Bing Search API’s 2025 retirement and the story rhymes. A first-party API that developers depend on gets pulled. Then everyone scrambles for alternatives.

The confusion in 2026 comes from three things that look like a Google News API but aren’t:

• The Custom Search JSON API is a supported, documented Google API — but it searches a specific site or a curated set of sites you configure. It does not cover the aggregated, ranked, source-attributed news.google.com feed.
• The News API for News Reader / publisher-facing products are for news publishers syndicating content, not for consumers reading the Google News SERP.
• The Knowledge Graph API returns entities, not article-level news results.

None of these is a Google News API in disguise. None give you “the ranked list of news articles Google shows for query X in country Y.” That surface simply has no official API behind it. To read it programmatically, you have to render and parse the results page. That is where the real options begin.

What you can actually get in 2026

Here’s the honest map. Four paths, each with a different trade-off between effort, fragility, and coverage.

Option	What it gives you	Metadata	Fragility	Best for
Google News RSS	Headlines + links per topic/query	Thin (title, link, pubdate, source name)	Low effort, aggressive rate limits, no ranking control	Occasional, lightweight pulls
Unofficial libraries / DIY scraper	Full SERP if it works	Full, when selectors hold	High — breaks on layout changes, gets blocked	Prototypes, tinkering
Custom Search JSON API	Web results from sites you configure	Structured, but not Google News	Low, but wrong surface	Site-scoped web search, not news
News-capable scraping API (cloro)	Live Google News SERP as parsed JSON	Full (title, link, source, date, snippet, thumbnail)	Low — maintenance absorbed by the provider	Structured, localized, at-scale monitoring

Let’s take each in turn.

1. Google News RSS — free, fragile, thin

Google still exposes RSS feeds for Google News. They cost nothing and need no key. You can build a topic feed or a keyword feed and pull it as XML. It’s the fastest way to get something moving.

The limits show up quickly. RSS returns thin metadata: a title, a link, a publish date, and a source name.

It gives you no control over ranking or result count. It offers no real per-country or per-language localization beyond the feed’s own locale. And it rate-limits hard if you poll aggressively.

There is also no snippet, no thumbnail, and no reliable position data. For anything past a lightweight pull, RSS is not a Google News API substitute.

If RSS is enough for your use case, don’t over-engineer it — we cover the exact feed URL patterns and their gotchas in the Google News RSS guide. Reach for something heavier only when RSS’s thinness or fragility actually bites.

Looking for alerts rather than a feed? Google Alerts is a related-but-different beast — email/notification-driven, not a queryable API. We break down what you can and can’t automate with it in the Google Alerts API post.

2. Unofficial scrapers and libraries — they break

Search GitHub and you’ll find a dozen “Google News” Python packages that scrape news.google.com and hand you structured articles. When they work, they’re great. The problem is when.

news.google.com is one of Google’s more aggressively defended surfaces. Anti-automation kicks in fast. The SERP DOM ships layout changes that break CSS and XPath selectors within hours of a release. A library that worked last month returns empty arrays today.

The maintainer may or may not push a fix. Add residential proxies, JavaScript rendering, and CAPTCHA handling, and you’ve rebuilt a scraping stack — the same conclusion we reach in the deep dive on scraping Google Search. For a prototype, that is a viable path. In production, it is a maintenance liability, not a dependable Google News API.

3. Custom Search Engine — doesn’t cover News

This is the most common wrong turn. Google’s Custom Search JSON API is real, supported, and documented. So people assume it is the answer.

It isn’t, because CSE searches a site or set of sites you configure, not the Google News aggregate. Point it at three news domains and you’ll get web-search-style results from those three domains. You do not get the ranked, deduplicated, source-attributed feed that news.google.com produces. For the Google News surface specifically, CSE is the wrong tool.

4. A News-capable scraping API — the durable option

The path that actually delivers “Google News results as JSON, for any query and country, that keeps working” is a purpose-built scraping API. cloro’s Google News endpoint renders the live Google News SERP and returns each article as parsed JSON — title, link, source, date, snippet, thumbnail, and position — with the browser fleet, proxy rotation, and selector maintenance handled for you. The endpoint returns roughly 10 results per query per page and accepts country/language localization, so you get the same data a DIY scraper would return without owning the anti-bot arms race.

If your use case is broad multi-source coverage rather than Google-News-specifically, that’s a different product category — aggregators like NewsAPI.org, GNews, and GDELT pull from their own indexes. We compare those side by side in the free news API roundup; this guide deliberately stays in the Google-News lane.

How to choose a Google News API alternative

Match the tool to the job. For an occasional headline pull, Google News RSS is enough. For a throwaway prototype, an unofficial library gets you moving. For site-scoped web search, Custom Search fits — though it is not a Google News API.

For structured, localized, at-scale monitoring that keeps working, a News-capable scraping API is the durable Google News API alternative. The rest of this guide backs that choice with data. First it measures how fast the SERP moves. Then it shows how to pull it in Python.

Freshness study: how fast the Google News SERP actually moves

The core argument for API-based monitoring over cached or RSS approaches is that the news SERP moves fast. We wanted a number, so we ran a small study in July 2026.

Method (directional, small sample). We scraped 48 news queries through cloro’s Google News endpoint, then re-scraped the same 48 queries in a second snapshot roughly 8 hours later, and compared the top-10 results per query. Treat these as directional signals from a small sample, not a precise law — but the direction is clear.

What we found, in our sampling:

• ~31% of top-10 results turned over across the ~8-hour window. Put differently, 69.2% of stories survived into the next snapshot.
• Churn is bimodal. Fast-moving brand and topic queries saw roughly 50% of the top 10 replaced — half the visible SERP was different stories 8 hours later. Niche terms churned slowly, around 11%.
• The endpoint returned ~10 results per query, consistent with a single page of Google News.

Why it matters. If you cache Google News results for a few hours — or rely on RSS you poll infrequently — you are, for the fast-moving queries that usually matter most (your brand, your competitors, a breaking topic), serving a SERP that’s meaningfully stale. Roughly a third of the surface has moved in a workday’s worth of hours, and up to half of it for hot queries. That’s the case for polling critical queries on a short interval against a live API rather than trusting a cache.

The practical read: pick your polling cadence by query volatility. High-signal brand and crisis queries deserve tight intervals; stable niche queries can be sampled far less often without missing much.

Tutorial: pulling structured Google News results with Python

Here’s the fastest path from zero to parsed articles. cloro’s News endpoint is a single POST to https://api.cloro.dev/v1/monitor/google/news. New accounts get 500 free credits, so you can run this before paying anything.

Python

import requests

resp = requests.post(
    "https://api.cloro.dev/v1/monitor/google/news",
    headers={
        "Authorization": "Bearer sk_live_your_api_key_here",
        "Content-Type": "application/json",
    },
    json={
        "query": "openai",
        "country": "US",
        "language": "en",
        "pages": 1,
    },
)

data = resp.json()
for article in data["result"]["newsResults"]:
    print(f"{article['position']:>2}. {article['title']}")
    print(f"    {article['source']} — {article['date']}")
    print(f"    {article['link']}\n")

curl

curl -X POST https://api.cloro.dev/v1/monitor/google/news \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "openai",
    "country": "US",
    "language": "en",
    "pages": 1
  }'

The parsed JSON you get back

{
  "success": true,
  "result": {
    "newsResults": [
      {
        "position": 1,
        "title": "Major Climate Summit Reaches Historic Agreement",
        "link": "https://example.com/climate-summit-agreement",
        "snippet": "World leaders agreed on new climate targets at the summit...",
        "source": "The Guardian",
        "date": "2 hours ago",
        "page": 1,
        "thumbnail": "https://example.com/images/climate-summit.jpg"
      },
      {
        "position": 2,
        "title": "Climate Scientists Warn of Urgent Need for Action",
        "link": "https://example.com/climate-report",
        "snippet": "Scientists warn that immediate action is needed...",
        "source": "BBC News",
        "date": "5 hours ago",
        "page": 1,
        "thumbnail": "https://example.com/images/climate-report.jpg"
      }
    ]
  }
}

Every newsResults entry is monitoring-ready: position for ranking, source for the publisher, date as Google’s relative timestamp (“2 hours ago”), plus the snippet and thumbnail. Drop the array straight into a database — no HTML parsing on your side.

Localizing by country and language

Google News surfaces very different sources country-by-country, so localization isn’t optional for a global brand — monitoring without it systematically misses regional coverage. Pass country (an ISO-3166 code) to route through that locale, and language for the results language:

# German-language Google News, from a German locale
json={
    "query": "künstliche intelligenz",
    "country": "DE",
    "language": "de",
    "pages": 1,
}

Swap country to GB, IN, BR, or any market you cover, and re-run. Same shape out, localized sources in. To go wider than one page, bump pages — each page is roughly 10 results. For the broader mechanics of localized SERP scraping, see the best SERP APIs comparison.

Four use cases (one snippet each)

Brand and news monitoring

Poll your brand name on a short interval and diff each snapshot against the last-seen set to catch new coverage the moment Google ranks it.

seen = set()  # persist this across runs

def new_coverage(brand):
    resp = requests.post(URL, headers=H, json={"query": brand, "country": "US"})
    fresh = []
    for a in resp.json()["result"]["newsResults"]:
        if a["link"] not in seen:
            seen.add(a["link"])
            fresh.append(a)
    return fresh  # alert on these

This is the backbone of the News Monitoring use case — see that page for the full brand-tracking pattern.

PR and campaign tracking

Track a launch keyword or campaign hashtag and measure pickup: how many outlets, which ones, and how fast the story climbs the SERP.

r = requests.post(URL, headers=H, json={"query": "acme series b funding", "country": "US"})
articles = r.json()["result"]["newsResults"]
print(f"{len(articles)} outlets covering the launch")
for a in articles:
    print(a["source"], "→", a["title"])

Finance and market signals

Run a ticker or company name on a tight cadence and feed the fresh headlines into your sentiment or event-detection pipeline — the freshness study above is exactly why finance use cases can’t tolerate a stale cache.

r = requests.post(URL, headers=H, json={"query": "NVDA earnings", "country": "US"})
for a in r.json()["result"]["newsResults"]:
    signal_pipeline.ingest(source=a["source"], headline=a["title"], when=a["date"])

Feeding news to LLM agents

Give an agent live, grounded news context by pulling the snippets and handing them to the model — far fresher than whatever was in its training cut-off.

r = requests.post(URL, headers=H, json={"query": user_topic, "country": "US"})
context = "\n".join(f"- {a['title']} ({a['source']}, {a['date']}): {a['snippet']}"
                    for a in r.json()["result"]["newsResults"])
answer = llm.complete(f"Using this fresh news, answer:\n{context}\n\nQ: {user_question}")

The bottom line

There is no official Google News API in 2026, and there won’t be — Google retired it in 2011 and moved on. Your real choices are RSS (free but thin and fragile), unofficial libraries (great until they break), Custom Search (real, but it doesn’t cover News), or a News-capable scraping API that returns the live Google News SERP as structured JSON. Given how fast the news SERP moves — roughly a third of the top 10 turning over in a workday, and up to half for hot queries — the durable answer for anyone doing real monitoring is API-based, localized, short-interval polling.

Try cloro’s Google News endpoint with 500 free credits — one API key, structured articles out, and the same credit pool covers Google Search and the AI answer engines too.