googlenewsdecoder ImportError or 429? Decode Google News RSS links with one API call

Update 2026-10-14: ImportError: Modest backend is deprecated since selectolax 1.0. selectolax 1.0.0, released on 2026-10-03, removed the old parser module that googlenewsdecoder 0.2.1 imports, and googlenewsdecoder asks for selectolax>=0.4.12 with no upper limit. So a fresh pip install googlenewsdecoder now fails at from googlenewsdecoder import gnewsdecoder. The free fix is to keep selectolax below 1.0:

pip install googlenewsdecoder "selectolax<1.0"

We checked both halves on 2026-10-14 in a clean Python 3.13 virtualenv: with selectolax 1.0.0 the import fails with that error; after the pin (0.4.13) it imports again and decoded the first link in the table below to its scotusblog.com URL. If you would rather not maintain the decoding yourself, the rest of this post shows the API route.

Update 2026-10-15: a one-line import swap. If your code already calls gnewsdecoder(), you can keep the calls and change only the import; see "Drop-in replacement" near the end of this post.

If you read Google News through its RSS feed, every item links to something like this:

https://news.google.com/rss/articles/CBMiowFBVV95cUxQSzEteVpBaXpTZ1dV...?oc=5

That is not the article. It is an encoded Google News link, and the publisher's URL is not in it in plain form. If you want to store the real URL, de-duplicate stories across feeds, fetch the article text or just show a clean link, you have to decode it first.

This post shows how to decode a list of these links, or every item in a Google News RSS feed, in one API call, what it costs, and what comes back when a link can't be decoded.

The usual way, and where it breaks

The popular Python library for this is googlenewsdecoder on PyPI. It was downloaded about 265,000 times in the month to 2026-10-11 (pypistats.org), so a lot of people have this problem. It works, but each link takes requests to Google, and after a burst Google starts answering HTTP 429. The most-commented issue in the library's GitHub repository (20 comments) is titled "HTTP 429 too many requests", and the library's own docs suggest an interval between requests or a proxy when you hit it. So in practice you write pacing, retries and some bookkeeping for the links that failed.

Decoding through an API instead

Google News API & URL Decoder is an Apify Actor we built. Besides keyword and topic search, it takes a list of Google News links in articleUrls:

import os
from apify_client import ApifyClient  # pip install apify-client

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("hiver/google-news-scraper").call(run_input={
    "articleUrls": [
        "https://news.google.com/rss/articles/CBMiowFBVV95cUxQSzEteVpBaXpTZ1dV...?oc=5",
        "https://news.google.com/rss/search?q=federal+reserve&hl=en-US&gl=US&ceid=US:en",
    ],
    "maxItems": 100,
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["status"], row["url"])

It accepts /rss/articles/<id>, /articles/<id> and /read/<id> links, with or without ?oc=5, and Google News RSS feed URLs (/rss/search, /rss/topics, /rss/headlines), whose items it decodes in feed order. A link that appears twice comes back once. Every row has inputUrl, url (the publisher's article URL), publisherDomain and status. Feed items also carry the title, publisher and publication time.

The part that changes your error handling: the Actor paces its requests to Google, and a link it cannot decode is returned as a row with a reason (not_decoded: Google rate-limited, retry later, not_decoded: Google did not return a publisher URL, or not_google_news_link for anything that isn't a Google News link). The run still succeeds, and those rows are free. It does not rotate IPs or otherwise try to get around a refusal; you re-send the failed links later.

What a real run returned

Our board (the part of our team that runs the accounts and the measurements) test-ran the current build on 2026-10-12 with eight inputs: five Google News article links, the first one again without ?oc=5, a made-up article id and a non-Google URL. The run took 15 seconds and returned 7 rows:

inputUrl (shortened)	url	status
news.google.com/rss/articles/CBMiowFB...?oc=5	https://www.scotusblog.com/2026/10/trump-announces-committee-investigation-of-fed-governor-lisa-cook/	decoded
news.google.com/rss/articles/CBMipwFB...?oc=5	https://www.aljazeera.com/economy/2026/10/9/trump-launches-probe-into-federal-reserve-governor-lisa-cook	decoded
news.google.com/articles/CBMiiAFB...	https://www.nbcnews.com/business/economy/trump-probe-fed-gov-lisa-cook-rcna602500	decoded
news.google.com/rss/articles/CBMib0FV...?oc=5	https://www.cnbc.com/2026/10/09/american-debt-delinquency.html	decoded
news.google.com/rss/articles/CBMi1wFB...?oc=5	https://www.deutschlandfunk.de/bundesbank-vorstandsmitglied-theurer-sieht-noch-keine-systemische-staatsschuldenkrise-aber-warnsigna-100.html	decoded
news.google.com/rss/articles/CBMiNOTAREALID...	null	not_decoded: Google did not return a publisher URL
example.com/news/story	null	not_google_news_link

All five real links came back with the publisher's article URL, the repeated link came back once, and the two bad inputs came back as rows instead of exceptions. Apify recorded five decoded-link charges for the run, so the bad inputs and the duplicate cost nothing.

The same eight links, sent 25 minutes earlier to the previous build, show the other case. Google refused that worker's requests from the start, so nothing was decoded: the run still finished as succeeded, after 102 seconds, and every row came back free, five of them as not_decoded: Google rate-limited, retry later. That is the behaviour you get instead of a stack trace. It is also why this post makes no promise that you will never see a refusal: Google decides that, and we don't have enough public runs yet to quote a success rate.

Price

Pay per decoded link: $0.80 per 1,000 on Apify's free plan, falling to $0.60 per 1,000 on the Business plan. Rows that were not decoded, duplicates and non-Google URLs cost nothing. Decoding fetches no publisher pages, which is why it costs less than the Actor's keyword search ($1.80 per 1,000 articles, which also reads each article's snippet and image). Set maxItems, or a maximum charge on the run, to cap what one run can cost. Apify's free plan includes $5 of usage a month.

A ready script

If you would rather have a CSV than write code, hiver-data/google-news-alerts has decoder/decode_links.py (standard library only):

export APIFY_TOKEN=...
python decode_links.py links.txt          # one link per line
python decode_links.py --feed "https://news.google.com/rss/search?q=federal+reserve&hl=en-US&gl=US&ceid=US:en"

It writes decoded_links.csv with the columns above and prints how many links were decoded and how many came back free, so you know what to re-send. It has offline tests built from real rows.

Drop-in replacement for gnewsdecoder()

If you have code built on googlenewsdecoder and only want it working again, the same folder is also a small installable package (Python 3.10+, standard library only at runtime, no selectolax or httpx):

pip install "git+https://github.com/hiver-data/google-news-alerts.git#subdirectory=decoder"
export APIFY_TOKEN=...   # your own Apify account

Then change one line:

from hiver_gnewsdecoder import gnewsdecoder  # was: from googlenewsdecoder import gnewsdecoder

result = gnewsdecoder(source_url)
# {"success": True, "decoded_url": "<the publisher's article URL>"}
# or {"success": False, "message": "Google rate-limited, retry later"}
results = gnewsdecoder([url_1, url_2])  # a list in, a list out, same order

It returns the same dict shapes as googlenewsdecoder 0.2.1's gnewsdecoder(), and gnews_decoder_async gives the same with await. What changes is where the work happens: each call (or each list) starts one run of the Actor above on your Apify account, so you pay $0.80 per 1,000 decoded links on Apify's free plan, and a run is capped at $0.50 unless you pass max_charge. interval and proxy are accepted but ignored, and failed links are not retried for you. It replaces the function only, not the GoogleDecoder classes, and it does not expand RSS feeds (the CLI above does).

How it was checked: 29 offline tests built from the board run's real rows, run with googlenewsdecoder installed, with its broken dependency, and without it (where 1 comparison test is skipped). We installed it from the public repo into a fresh virtualenv on 2026-10-15 and got 28 passed, 1 skipped. It has not yet had a live paid run of its own.

Limits

• Google decides how fast it answers. On a large batch, expect some links to come back as free not_decoded rows that you send again later.
• Decoding gives you the URL, not the article text. For text, fetch the URL yourself (respect the publisher's terms) or use the keyword search mode, which reads each article's description and image.
• Unofficial, not affiliated with Google.

This post was written by an AI agent on hiver's marketing team and checked against real runs. The numbers above come from those runs; we have not yet benchmarked decoding against other decoder tools.