The first version was fifteen lines and it was wrong in a way I couldn't see from the output. So I pulled a full week of coverage three different ways and counted.

A company news watcher is a filter chain, not a query. Over seven days (2026-08-30 to 2026-09-05) there were 5,718 articles mentioning NVIDIA — about 817 a day. Five filtering stages got that to 161 alerts, or 23 a day. This post is the measurements behind each stage, and the finished script.

This is for developers who want a company news feed they can trust, and analysts who need to know what their alerts are silently dropping.

What the week showed, in four lines:

• Searching headlines for the company name finds 29.8% of the coverage that mentions it.
• Entity resolution alone isn't a fix — it missed 180 articles that had "nvidia" in the headline.
• Only 31.6% of the coverage is in English.
• 12.5% of what survives filtering is the same story republished under a near-identical headline.

Measured 2026-09-06 against the APITube news API, over articles published 2026-08-30 to 2026-09-05. The pull script (pull.py) and the resulting counts (data.csv) sit alongside this post.

The fifteen-line version

Start with the obvious thing: search headlines for the company name.

curl -s -G "https://api.apitube.io/v1/news/everything" \
  -H "X-API-Key: $APITUBE_API_KEY" \
  --data-urlencode "title=nvidia" \
  --data-urlencode "per_page=2" \
  --data-urlencode "published_at.start=2026-08-30" \
  --data-urlencode "published_at.end=2026-09-05"

Trimmed to the fields that matter, one article comes back like this:

{
  "id": 3078309425,
  "title": "Nvidia earnings highlight remarkable growth",
  "published_at": "2026-09-02T17:56:16.000Z",
  "language": "en",
  "source": {
    "domain": "proactiveadvisormagazine.com",
    "type": "news"
  },
  "entities": [
    {
      "id": 1280220,
      "name": "Nvidia",
      "type": "organization",
      "frequency": 3,
      "sentiment": { "score": 0.46, "polarity": "positive" },
      "metadata": {
        "aliases": ["NVIDIA", "nVidia", "NVDA"],
        "is_public_entity": true
      }
    }
  ],
  "sentiment": {
    "overall": { "score": 0.64, "polarity": "positive" }
  },
  "is_duplicate": false,
  "story": { "id": 3078309425 }
}

Two fields decide everything later: entities[].frequency (how many times the company is actually named in the piece) and entities[].id (the canonical company, independent of spelling).

The headline query finds 30% of the coverage

Here is the part that made me throw away version one. I ran the same week twice — once filtering on the headline, once on the canonical entity id.

The headline query misses 3,890 articles — a supplier's export licence, a hyperscaler's capex call, a competitor's benchmark. Those are the stories that move a position, and they rarely put "NVIDIA" in the headline.

The obvious fix is to drop the headline query and use entity resolution alone. That is also wrong. 180 articles had "nvidia" in the headline and no NVIDIA entity extracted at all — 9.8% of the headline set. Named-entity recognition misses things too, especially on smaller and non-English outlets.

Neither filter is a superset of the other, so the watcher queries both and unions the results. Unlike a single-strategy filter, the union costs one extra request per window, which means you stop choosing between the two failure modes and just pay for both.

Two thirds of it isn't in English

Language of all 5,718 articles mentioning NVIDIA over the seven days, from the language field on each article.

Of those 5,718 articles, 1,806 were in English — 31.6%. German was 9.4%, Spanish 7.4%, Chinese 6.4%, French 5.7%, Italian 4.9%, Japanese 4.2%, Portuguese 4.1%.

If you never set a language filter, you don't get a broader watcher — you get a mostly-unreadable one, and your theme keywords (written in English) silently fail against it. If you do set language=en, be honest that you just dropped two thirds of the world's coverage. I set it, because I can't read the rest. That's a choice, not a default.

The five stages, with the numbers

Each stage applied in order to the same 7-day pull. Counts are articles, not alerts sent.

Each stage below is one rule with one threshold, applied in order.

Stage 3 is the one worth explaining. Only 32.2% of entity-matched articles have NVIDIA in the headline; the other two thirds mention it in passing — a monitor review, a fund's holdings list, an unrelated AI story name-checking the chip. Requiring the headline and at least two mentions in the body is a cheap proxy for "this article is about NVIDIA", and it cut 258/day to 97/day.

Stage 4 removed 12.5% of what survived stage 3. Those 924 source domains republish each other constantly — one acquisition story appeared eight times under near-identical headlines. Normalising the title to a sorted set of its long words catches these without any similarity library.

Stage 5 splits the remainder into themes, which is also the alert budget: earnings 11.4/day, leadership 10.0/day, legal 2.6/day, export controls 2.1/day. Those sum to more than 23 because one article can match two themes — an earnings call that announces a CFO change lands in both.

The watcher

import json, os, re, urllib.parse, urllib.request

API = "https://api.apitube.io/v1/news/everything"
KEY = os.environ["APITUBE_API_KEY"]
NVIDIA = 1280220

THEMES = {
    "earnings": (
        r"earnings|revenue|quarter|guidance|\beps\b"
        r"|results|forecast"
    ),
    "leadership": (
        r"\bceo\b|jensen huang|\bcfo\b|resign"
        r"|steps down|appoint"
    ),
    "export": (
        r"export|sanction|china|\bban\b|restrict"
        r"|licen[cs]e|blackwell|tariff"
    ),
    "legal": (
        r"lawsuit|sue[sd]?\b|antitrust|probe"
        r"|investigat|settle|court"
    ),
}
THEME_RE = re.compile("|".join(THEMES.values()), re.I)

def fetch(**params):
    params.setdefault("per_page", 200)
    url = f"{API}?{urllib.parse.urlencode(params)}"
    req = urllib.request.Request(url, headers={
        "X-API-Key": KEY,
        # urllib's default UA gets a 403
        "User-Agent": "nvidia-watch/1.0",
    })
    resp = urllib.request.urlopen(req, timeout=60)
    payload = json.load(resp)
    # a typo'd filter is ignored, not rejected
    for w in payload.get("meta", {}).get("warnings", []):
        print("WARNING", w["code"], w["message"])
    return payload

def mentions(article, entity_id):
    for e in article.get("entities", []):
        if e["id"] == entity_id:
            return e.get("frequency", 0)
    return 0

def normalise(title):
    text = re.sub(r"[^a-z0-9 ]", " ", (title or "").lower())
    words = {w for w in text.split() if len(w) > 3}
    return " ".join(sorted(words))

def watch(entity_id, keyword, start, end, language="en"):
    seen, out = set(), []
    # stage 1: union of both queries
    for field, value in (("entity.id", entity_id),
                         ("title", keyword)):
        page = 1
        while True:
            q = {"published_at.start": start,
                 "published_at.end": end,
                 "page": page, field: value}
            data = fetch(**q)
            rows = data.get("results", [])
            for a in rows:
                # stage 2: language
                if a.get("language") != language:
                    continue
                # stage 3: headline and 2+ mentions
                title = a.get("title") or ""
                if not re.search(keyword, title, re.I):
                    continue
                if mentions(a, entity_id) < 2:
                    continue
                # stage 4: near-duplicate headline
                key = normalise(title)
                if key in seen:
                    continue
                # stage 5: matches a watch theme
                blob = f"{title} {a.get('description', '')}"
                if not THEME_RE.search(blob):
                    continue
                seen.add(key)
                out.append(a)
            if not rows or not data.get("has_next_pages"):
                break
            page += 1
    return out

if __name__ == "__main__":
    hits = watch(NVIDIA, "nvidia", "2026-08-30", "2026-09-05")
    n = len(hits)
    print(f"\n{n} alerts over 7 days ({n / 7:.1f}/day)\n")
    for a in sorted(hits, key=lambda x: x["published_at"]):
        blob = f"{a['title']} {a.get('description', '')}"
        theme = next(t for t, p in THEMES.items()
                     if re.search(p, blob, re.I))
        day = a["published_at"][:10]
        print(f"[{theme:10s}] {day}  {a['title'][:70]}")

Standard library only. Running it just now returned 153 rather than the 161 in my archived pull — the index keeps ingesting, so a re-run of a past window is close but not byte-identical. Worth knowing before you write a test that asserts an exact count.

Piping it into Telegram is four more lines and a bot token; the filtering is the part that was hard.

Five things that cost me time

There is no ticker filter. ticker=NVDA returns HTTP 200 and quietly ignores you. NVDA lives in entities[].metadata.aliases alongside is_public_entity: true, so resolve ticker → entity id once, store the map, and filter on the id.

organization.name is case-sensitive. organization.name=Nvidia works. organization.name=NVIDIA returns HTTP 400, ER0220, "entity organization name 'NVIDIA' not found." The all-caps spelling most people type is the one that fails.

Unknown parameters are warnings, not errors. entity.name and ticker both come back 200 with meta.warnings[].code == "ER0368" and unfiltered results. A typo doesn't crash your watcher, it floods it. Print meta.warnings — that's the two lines in fetch() above.

Headline search defaults to a 31-day window (ER0366) if you don't pass published_at.start and published_at.end. Your "last 24 hours" alert is quietly a month.

Python's default User-Agent gets a 403. urllib sends Python-urllib/3.x and the edge rejects it. Set any real User-Agent and it works — this cost me twenty minutes of blaming my API key.

Frequently asked questions

How do I get news alerts for a specific company?

The reliable way to get news alerts for a specific company is a five-stage filter chain rather than a single query, because no single filter is both precise and complete. Query the company's canonical entity id, union it with a headline keyword search, then filter by language, require the company in the headline with two or more body mentions, drop near-duplicate titles, and match against theme keywords. In this measurement that chain reduced 817 articles a day to 23.

Why do my company news alerts return irrelevant articles?

Company news alerts return irrelevant articles because a mention is not a subject. Only 32.2% of articles that mention NVIDIA put it in the headline; the rest are passing references in unrelated stories. Requiring a headline match plus frequency >= 2 removes most of them.

Can I filter news by ticker symbol?

No — this API has no ticker parameter, and passing one is silently ignored rather than rejected. The ticker appears inside entities[].metadata.aliases, so build your own ticker-to-entity-id table once and filter on entity.id.

How do you deduplicate news articles from multiple sources?

The cheapest way to deduplicate news articles across sources is normalised-headline matching, because syndicated copies keep the same words while rewording punctuation and framing. Normalise each headline to a sorted set of its words longer than three characters and treat a repeat as a duplicate. Across 924 source domains that removed 12.5% of the surviving articles, with no similarity library.

Is entity resolution enough on its own?

No — entity resolution alone is not enough, because entity extraction has its own recall gap. It missed 180 articles that had the company name in the headline — 9.8% of the headline-matched set. Query both ways and union the results.

Making it yours

To point this at another company:

1. Find the entity id. Pull any article that mentions the company and read entities[] — the id, the aliases and is_public_entity are all in there. Store the mapping; it doesn't change.
2. Rewrite THEMES. The stage thresholds transfer between companies, the theme regexes don't — "export controls" matters for a chipmaker and means nothing for a bank.
3. Re-measure the funnel. Count what each stage drops for your company before you trust the output. A quiet mid-cap won't need stage 5 at all; a bank will need a different stage 3.

Mine only looked reasonable after I counted what it threw away.

Disclosure: I work on APITube, which is the API in the code above — free tier at apitube.io. The measurement approach works against any news API that exposes entity ids and per-article mention counts.

Resources

• APITube news API documentation — endpoints, parameters, response schema
• Google Alerts — the no-code baseline: no API, no deduplication, no entity resolution
• Perigon's NVIDIA monitoring guide — good on entity resolution as a concept, no code or numbers

A news watcher is a scheduled query against a news index plus the filtering you write yourself: deduplication, theme routing, and a noise threshold. The query is the easy part. Every vendor blog stops there. This one doesn't, because the query returned 820 articles in a week and we only wanted about fifteen a day.

The watcher runs four steps in this order, and every one of them turned out to matter:

1. Query one day of coverage from a news index, paging until the index says there's no next page.

2. Deduplicate by title token overlap, because the same filing reaches you from a dozen newsrooms.

3. Route each article into a theme — launch, people, legal, outage, money — with regex over title and description.

4. Threshold on source authority, then deliver what's left.

All numbers below come from one collection run against the APITube news API: English-language articles with "OpenAI" in the title, 30 August to 6 September 2026, 820 articles across 372 sources. Disclosure: we work on APITube. Where it fell over, we say so — most of this article is about it falling over.

The obvious approach, and why it failed for OpenAI

Every guide to company monitoring says the same thing: don't search for a keyword, filter by the company entity. Keyword search catches "Apple" the fruit; entity resolution catches Apple Inc. It's good advice. It also assumes the entity exists in the vendor's graph.

APITube has an organization.name filter. Here is what a week of coverage looks like through it:

OpenAI isn't in the entity graph at all. Neither is Alphabet. Meta resolves to something with zero articles, Tesla to something with eleven, and Apple returns the same count as Microsoft while serving us a cinnamon roll recipe. We also pulled every organization entity out of 195 OpenAI articles: Hugging Face, SES S.A., Microsoft, Anthropic, Gruppo API, and a person called Joseph Altman. Not one mention of OpenAI.

So the rule isn't "use entity filters" or "use keywords". It's check whether your entity exists before you design around it, which is one request:

curl -s "https://api.apitube.io/v1/companies?name=OpenAI" \
  -H "X-API-Key: $APITUBE_API_KEY"
# {"status":"ok","limit":100,"page":1,"has_next_pages":false,"results":[]}

Empty array. The autocomplete endpoint agrees — GET /v1/suggest/entities?prefix=OpenAI returns Openair Frauenfeld, a Swiss music festival. Unlike a keyword search, an entity filter fails silently when the entity is missing: you get zero rows and no error telling you the concept doesn't exist, which means a watcher built on it stays quiet forever and looks like it's working.

For OpenAI, the watcher runs on title=OpenAI and does its own filtering downstream.

What the watcher queries

curl -s -G "https://api.apitube.io/v1/news/everything" \
  -H "X-API-Key: $APITUBE_API_KEY" \
  -d title=OpenAI \
  -d language.code=en \
  -d published_at.start=2026-09-05 \
  -d published_at.end=2026-09-06 \
  -d sort.by=published_at -d sort.order=desc \
  -d per_page=100

One result, trimmed to the fields the watcher touches:

{
  "id": 3079204730,
  "title": "Seattle Times, Newsday Take OpenAI And Microsoft To Court Over Copyright Claims",
  "href": "https://www.timesnownews.com/technology-science/seattle-times-newsday-take-openai-and-microsoft-to-court-over-copyright-claims-article-156045463",
  "published_at": "2026-09-05T04:23:43.000Z",
  "source": { "domain": "timesnownews.com", "rankings": { "opr": 6 } },
  "sentiment": { "overall": { "polarity": "neutral" } },
  "story": { "id": 3079204730 },
  "is_duplicate": false
}

Two things bit us here, both worth knowing before you schedule anything.

published_at.end is exclusive. Asking for start=2026-09-06&end=2026-09-06 returns zero rows; end=2026-09-07 returns the day. A daily watcher written the obvious way skips every day it runs and never errors.

Unknown parameters are sometimes ignored in silence. entity.name, body and keyword at least come back flagged in meta.warnings, so log that array. search doesn't: search=zzqqxwv returned three cheerfully unrelated articles. Before trusting any filter, send it a nonsense value and check you get nothing back.

Deduplication is the part nobody writes about

820 articles from 372 sources over seven days, and the same story arrives four or five times. We tried four ways of collapsing them on the same dataset:

The vendor's own duplicate flag was false on all 820 rows. Story clustering caught eight. Whatever your provider promises about deduplication, measure it on your own query before you rely on it — ours cost us one line of Python to check and would have cost us a fifth of our alert volume to skip.

Token overlap is what the watcher uses. Strip punctuation and stopwords, compare titles as sets, drop anything that overlaps an already-kept title by 60% or more:

STOP = set("a an the of in on at to for and or with by from is are was were as "
           "its it this that new says said after over into be will has have "
           "how why what when who".split())

def tokens(title):
    return {w for w in re.sub(r"[^a-z0-9 ]", " ", title.lower()).split()
            if w not in STOP and len(w) > 2}

def dedup(articles):
    kept, seen = [], []
    for a in articles:
        t = tokens(a["title"])
        if any(len(t & s) / len(t | s) >= 0.6 for s in seen if t and s):
            continue
        seen.append(t)
        kept.append(a)
    return kept

It catches syndication, not rewriting. On 5 September the copyright suit reached us as four separate alerts — "Seattle Times, Newsday sue OpenAI, Microsoft", "Seattle Times, Newsday Take OpenAI And Microsoft To Court", "US newspapers sue OpenAI, Microsoft", and "Newsday sues OpenAI and Microsoft" — because four newsrooms wrote four genuinely different sentences. Dropping the threshold to catch those starts merging unrelated stories. We kept the duplicates and moved on; embeddings would fix it, and would also turn eighty lines into a service.

Routing into launches, departures and lawsuits

Five regexes over title plus the first 400 characters of the description:

THEMES = {
    "launch": r"(launch\w*|releas\w*|unveil\w*|introduc\w*|roll\w* out|debut\w*|announc\w*|general availability|preview)",
    "people": r"(hir\w+|join\w+|depart\w+|resign\w*|step\w* down|quit\w*|fired|ousted|appoint\w*|new (ceo|cto|cfo|president))",
    "legal":  r"(lawsuit\w*|sue[sd]?\b|suing|court|judge|settl\w+|copyright|antitrust|subpoena|alleg\w+|litigation|injunction|regulat\w+|probe|investigat\w+)",
    "outage": r"(outage\w*|downtime|degrad\w+|incident\w*|status page|disruption\w*|restored|went down)",
    "money":  r"(funding|fundrais\w*|valuation|\bround\b|invest\w+|acqui\w+|\bipo\b|billion (deal|agreement)|stake)",
}
THEMES = {k: re.compile(v, re.I) for k, v in THEMES.items()}

def route(a):
    text = a["title"] + " " + (a.get("description") or "")[:400]
    return [name for name, rx in THEMES.items() if rx.search(text)]

Across the week: launch 284 articles (34.6%), legal 191 (23.3%), money 68 (8.3%), outage 62 (7.6%), people 53 (6.5%). 259 articles (31.6%) matched nothing and 90 (11.0%) matched more than one theme.

Reading the description roughly doubles recall and imports someone else's summary into your routing. Of 62 outage matches, 38 matched only in the description — including "OpenAI Says It Wants to Create a Standard for Revealing AI Alignment Meltdowns", which is a policy story that says "incidents" in its second sentence. Match people and legal across title and description, because a departure is often buried in paragraph three. Match outage on the title alone.

That 31.6% residual is not a bug to tune away. It's GPT-6 benchmark scores, congressional candidates expensing subscriptions, and agents editing a German wiki — real coverage that no keyword set anticipated. Send it as a low-priority bucket rather than dropping it.

How loud should the watcher be

Every article carries source.rankings.opr, an authority score from 0 to 8. Pick your threshold by how many alerts a day you'll actually read:

Below 5 you're subscribing to the whole internet — the top ten domains are only 17.2% of volume, so the long tail is where the count lives. At 7 you get eleven a day and you're reading TechCrunch, which you already do. We run at 6.

The table above applies the threshold to raw articles. In the watcher it runs after dedup, so the numbers differ: 820 raw → 641 after dedup → 177 above opr >= 6 → 118 with a theme. Seventeen alerts a day, of which the ones we'd have wanted to know about within the hour — the GPT-6 Astra launch, four newsrooms filing suit, the wiki incident — all survived.

Cost, since nobody mentions it: a day of OpenAI coverage is one to two requests at per_page=100, so a daily digest is about 500 requests a year and a fifteen-minute loop is roughly 35,000. Both fit inside a free tier on most providers. The expensive version is the one that polls every source separately.

The whole script

import os, re, sqlite3, datetime as dt
import requests

API = "https://api.apitube.io/v1/news/everything"
KEY = os.environ["APITUBE_API_KEY"]
MIN_OPR = 6

def fetch(day, query="OpenAI"):
    """One day of coverage. published_at.end is exclusive — pass the NEXT day."""
    out, page = [], 1
    while True:
        r = requests.get(API, headers={"X-API-Key": KEY}, timeout=30, params={
            "title": query,
            "language.code": "en",
            "published_at.start": day.isoformat(),
            "published_at.end": (day + dt.timedelta(days=1)).isoformat(),
            "sort.by": "published_at", "sort.order": "desc",
            "per_page": 100, "page": page,
        })
        r.raise_for_status()
        body = r.json()
        for w in (body.get("meta") or {}).get("warnings", []):
            print("API warning:", w["message"])
        out += body.get("results", [])
        if not body.get("has_next_pages"):
            return out
        page += 1

def loud_enough(a):
    return (a["source"].get("rankings", {}).get("opr") or 0) >= MIN_OPR

def main():
    db = sqlite3.connect("seen.db")
    db.execute("CREATE TABLE IF NOT EXISTS seen (id INTEGER PRIMARY KEY)")
    yesterday = dt.date.today() - dt.timedelta(days=1)

    raw = fetch(yesterday)
    fresh = [a for a in raw
             if not db.execute("SELECT 1 FROM seen WHERE id=?", (a["id"],)).fetchone()]
    digest = [a for a in dedup(fresh) if loud_enough(a) and route(a)]

    for a in digest:
        print(f"[{'/'.join(route(a))}] {a['title']}  "
              f"({a['source']['domain']}, opr {a['source']['rankings']['opr']})")

    db.executemany("INSERT OR IGNORE INTO seen VALUES (?)", [(a["id"],) for a in raw])
    db.commit()

if __name__ == "__main__":
    main()

The SQLite table exists because reprints trickle in for days and the dedup pass only sees one run at a time. Point print at a Telegram sendMessage call or an SMTP digest and you're done. Run it on cron at 08:00 for a morning digest, or every fifteen minutes if you want legal and outage fast — the freshest article in our collection was 53 minutes old when we pulled it, so a quarter-hour loop is not obviously wasteful.

Real output, 5 September:

2026-09-05: 87 articles -> 78 after dedup -> 15 alerts
[outage] OpenAI confirms 'wiki incident,' says it's 'working on a framework'  (techcrunch.com, opr 8)
[launch] OpenAI Launches GPT-6 Astra With Computer Use Tools  (dev.to, opr 7)
[legal] Newsday sues OpenAI and Microsoft over copyright infringement  (newsday.com, opr 6)
[launch/money] Nvidia inks $13 billion deal to buy the AI startup hacked by OpenAI  (egyptindependent.com, opr 6)

Swap the query, keep the pipeline

Change title=OpenAI to organization.name=Anthropic and everything downstream still works — dedup, routing and thresholds don't care where the rows came from. That's the point of doing the filtering yourself. Just re-run the entity check first, and re-measure the duplicate rate: 21.8% is what OpenAI's coverage looked like, not a constant.

Questions we had while building this

How do I monitor OpenAI news automatically?

Monitoring OpenAI news automatically means scheduling a daily query against a news index for articles with OpenAI in the title, then deduplicating, routing into themes, and thresholding on source authority before anything is delivered. The query takes ten lines; the filtering is where the work is. On our dataset that pipeline reduced 820 articles a week to 17 alerts a day.

Does OpenAI have an RSS feed?

OpenAI publishes an RSS feed at https://openai.com/news/rss.xml, free and complete for anything the company says about itself. It will never carry a lawsuit filed against OpenAI, an executive leaving, or an outage the company hasn't acknowledged yet. Subscribe to it and run a third-party watcher; they cover different things.

How do I track a company's news with Python?

Tracking a company's news in Python starts with checking that the entity exists (/v1/companies?name=...), falling back to title search if it doesn't, paging through with per_page=100, remembering what you've already sent in SQLite, and deduplicating by token overlap. That's roughly eighty lines with requests and the standard library.

How do you filter duplicate news articles?

Duplicate news articles are best filtered by comparing normalised titles as token sets and dropping anything that overlaps an already-kept title by 60% or more. On our dataset that caught 179 of 820 articles, against 106 for exact title matching and 0 for the API's own duplicate flag. Rewritten headlines still slip through; embeddings are the next step.

What's the best API for AI news?

The best API for AI news is whichever one resolves the entities you actually care about, and that is a single request to find out — don't take a vendor's entity coverage on faith, including ours. We used APITube because it exposes source authority scores and a count endpoint, which is what made the thresholds in this article measurable. APITube is one of the APIs we mentioned — there's a free tier at apitube.io.

Resources

• APITube news API docs — endpoints and filters used here

• OpenAI news RSS feed — first-party announcements

• perigon.io on monitoring OpenAI — the entity-first playbook this article argues with