How fresh is Google News, and how often should you check it? Data from 24 topics

If you monitor news for a brand, a market or a client, you have to decide how often to check. Too rarely and you are late. Too often and you pay for requests that return the same list. Most advice on the question is a guess.

We measured it. We took three snapshots of 24 Google News topics over about an hour and counted how old the results were and how many of them changed. This guide has the numbers, the code, and a polling guide you can adapt. We used the Google News API on 17 October 2026. News moves, so yours will differ.

How we ran it

We used the same 24 topics as in which publishers dominate Google News: 6 technology, 6 business and finance, 5 sports, 4 health and science and 3 entertainment, all with country set to us. Snapshot A finished at 06:38 UTC, snapshot B at 07:10 and snapshot C at 07:37. That is 72 requests and 72 credits, and every one completed.

One caveat comes first. 06:38 UTC is 2:38 in the morning in New York. These snapshots show an overnight picture for the US, and daytime is likely busier, which we did not test.

How old are the results

At 06:38 UTC, the 394 results in snapshot A had a median age of 19.5 hours:

We had run these same topics earlier, at 17:21 UTC, which is midday on the US east coast. The picture was different:

The share of very fresh results depended on the time of day: 31% were under six hours old at midday, and 7% overnight. The share under 24 hours barely moved. By topic group, sports had the freshest results in the overnight snapshot, with a median of 16 hours and 18% under six hours, and business, finance, health and science the oldest, with a median of 24 hours.

How much changes in an hour

For each topic, we counted the links in a later snapshot that were not in an earlier one:

Over an hour, roughly one link in five on page 1 was new, and 80% of the links from the first snapshot were still listed an hour later. In total, 92 of the 403 links in the last snapshot were not in the first.

The change depended on the subject:

Individual topics varied more. In the hour, nvidia had 14 new links out of 25, premier league 10 of 18, box office 9 of 19 and inflation report 8 of 16. At the other end, cybersecurity breach and housing market had none, and oil prices and tesla stock one each.

A new link is not a new story

We expected links that were new to the list to be minutes old. They were not. The 92 links that appeared between the first and the last snapshot had a median age of 16.0 hours, against 21.0 hours for the links that had been listed all along. They were younger, but mostly by hours, not minutes.

So “new in the list” and “just published” are different things. A link can enter the list because the story is picked up later, or re-ranked, or published hours before. If your alert says “new story”, it means new to your monitor, and you should show the age Google gives (16 hours ago) next to it.

What this suggests about polling

The data is a snapshot of one night, so treat this as a starting point:

• Hourly looks like enough for most topics. 80% of the links stayed listed for the whole hour, so an hourly check would have seen most of them. Our test does not measure links that came and went within the hour, so a story that appeared for 20 minutes could be missed.
• Fast topics change more. Sports lost a third of its list in an hour. If you follow a live event, check more often.
• Slow topics need less. Health and science changed by 12% an hour, so a few checks a day is plenty.
• Check the time of day. The overnight snapshots were the quiet ones. Run your own for a day to see your topics’ rhythm.
• Use one request per topic. Page 1 held 10 to 25 results, and a topic that changes a few links an hour does not need deeper pages.

The code

Put your key in an environment variable:

export CRAWLERDATA_API_KEY="YOUR_API_KEY"

import os
import re
import statistics
import time

import requests

API_URL = "https://api.crawlerdata.com/v1/jobs"
HEADERS = {"Authorization": f"Bearer {os.environ['CRAWLERDATA_API_KEY']}"}

UNITS = {"minute": 1, "hour": 60, "day": 1440, "week": 10080, "month": 43200}


def google_news(query, country="us", retries=4):
    body = {"endpoint": "google-news", "params": {"query": query, "country": country}, "queue": "live"}
    for attempt in range(retries):
        resp = requests.post(API_URL, json=body, headers=HEADERS, timeout=250)
        if resp.status_code == 429:
            time.sleep(int(resp.headers.get("retry-after", 10)))
            continue
        resp.raise_for_status()
        job = resp.json()["job"]
        if job["status"] == "completed":
            return resp.json()["result"]["news_results"]
        if "retry" in (job["error"] or "").lower():
            time.sleep(5 * (attempt + 1))
            continue
        raise RuntimeError(job["error"])
    raise RuntimeError("News search failed after retries")


def age_minutes(text):
    """'9 hours ago' -> 540. Returns None for text it does not recognise (for example other languages)."""
    m = re.fullmatch(r"(\d+) (minute|hour|day|week|month)s? ago", text or "")
    return int(m.group(1)) * UNITS[m.group(2)] if m else None


def freshness(results):
    """Median age and the share of results under 1, 6 and 24 hours old."""
    ages = [a for a in (age_minutes(r["date"]) for r in results) if a is not None]
    return {
        "results": len(ages),
        "median_hours": round(statistics.median(ages) / 60, 1),
        "under_1h": round(100 * sum(a < 60 for a in ages) / len(ages)),
        "under_6h": round(100 * sum(a < 360 for a in ages) / len(ages)),
        "under_24h": round(100 * sum(a < 1440 for a in ages) / len(ages)),
    }


def new_links(previous, current):
    """Articles in `current` that were not in `previous` (compare by link)."""
    seen = {r["link"] for r in previous}
    return [r for r in current if r["link"] not in seen]

Check a topic, wait, check again:

first = google_news("nba")
print(freshness(first))
time.sleep(60)
second = google_news("nba")
print(len(new_links(first, second)), "new of", len(second))

It printed:

freshness: {'results': 27, 'median_hours': 13.0, 'under_1h': 0, 'under_6h': 37, 'under_24h': 81}
after 60 s: 0 new of 27 results []

On our 394 results from snapshot A, freshness returned a median of 19.5 hours, 1% under an hour, 7% under six and 59% under 24. In a loop, keep the set of links you have seen and pass each fresh result through new_links, as in the monitor from our Google News guide.

What it costs

Every check is 1 credit per topic, on every queue. Starter is $1.00 per 1,000 requests and the largest pack is $0.30 per 1,000, see pricing.

Failed requests are not charged. Matching your frequency to each topic, rather than one rate for everything, is the cheapest way to keep up.

Next steps

You now have numbers on how old Google News results are, how fast the list changes by topic, and the code to measure your own topics. The Google News API page lists every parameter with a full example response, and local news by city covers how to target a place.