DEV Community: APITube News API

We put the headlines on an e-ink screen so we'd stop opening X

APITube News API — Sun, 18 Oct 2026 05:42:28 +0000

We put the headlines on an e-ink screen so we'd stop opening X

We wanted the top of the news on a shelf, not in a feed. An e-ink news display is an e-paper panel driven by a small computer that redraws a short list of headlines on a schedule and holds the image with no power in between. Unlike a Raspberry Pi e-ink dashboard that mixes weather, calendar and stock tickers, this one shows headlines and nothing else. Ours is a Waveshare 7.5" e-Paper HAT (800×480, black and white) on a Raspberry Pi, fed by a news API, redrawn by cron once an hour. The board shows nine headlines: three top stories, two business, two science & tech, two sport.

Three things we measured before calling it done. At 18 px, nine headlines fit on 800×480 with two-line wrapping; a source column would have cost three of them. The API's /top-headlines endpoint returns HTTP 500 or 502 the moment you add category.id, so the category tabs come from /everything with a source-rank floor. And across 24 hourly snapshots, the front page's top three changed by 0.83 headlines per hour — in 8 of 23 hours it didn't change at all — and the category tabs by 0.61 to 0.96 of their two lines. The whole nine-line board averaged 3.13 new lines per hour.

This post is for anyone with a Pi, a Waveshare panel and 40 minutes. The script is complete and below. No hardware photos here: the image you'll see is the exact 1-bit frame the script pushes to the panel.

Takeaways

9 headlines on a 7.5" panel at 18 px; 75% of 256 real headlines fit on one line at that size, none needs more than two. In 2 of 24 reconstructed hours one headline had to be dropped to fit.
/top-headlines + category.id = HTTP 500/502 on 5 of 5 tries. Category tabs use /everything + source.rank.opr.min=8 instead.
Science & tech at rank ≥ 8 is only 8 articles a day. One notch lower plus ignore.source.domain=dev.to gives 83.
Front page top 3: 0.83 changes per hour, 8 of 23 hours with no change. Business 0.96 of 2, science & tech 0.74, sport 0.61. Refreshing every 3 hours instead would show 6.71 new lines of 9 per redraw.
An API call takes 3.53 s median from a laptop; the panel's full refresh is the slow part, so hourly is plenty.

What's on the shelf

Raspberry Pi 4 (we ran it here; a Pi Zero 2 W has the same 40-pin header and the script only needs requests and Pillow, so it should be fine — we didn't test it).
Waveshare 7.5" e-Paper HAT, V2. 800×480, 1-bit. The HAT sits straight on the GPIO header, no wiring.
A picture frame from the drawer, with the mat cut to the panel's active area.

Software: Raspberry Pi OS, Python 3, Pillow, requests, the Waveshare driver from github.com/waveshare/e-Paper, and a news API key. We used APITube, where we work — more on that at the end.

"Top headlines by category" doesn't exist in the API, so we built it

The obvious call works. /v1/news/top-headlines with a language returns a ranked list from high-authority sources and even a bare headlines array:

curl -s "https://api.apitube.io/v1/news/top-headlines?language.code=en&per_page=3&fl=title,source.domain,published_at" \
  -H "X-API-Key: $APITUBE_API_KEY"

{
  "status": "ok",
  "headlines": [
    "NBC helicopter crash in LA kills at least three people with others injured",
    "Federal Reserve raises interest rates for the first time since 2023",
    "Trump administration will comply with mail ballot ruling by Supreme Court, Blanche says"
  ],
  "results": [
    {"title": "NBC helicopter crash in LA kills at least three people with others injured",
     "source": {"domain": "theguardian.com"}, "published_at": "2026-09-16T04:32:48.000Z"},
    {"title": "Federal Reserve raises interest rates for the first time since 2023",
     "source": {"domain": "cbsnews.com"}, "published_at": "2026-09-16T18:31:07.000Z"},
    {"title": "Trump administration will comply with mail ballot ruling by Supreme Court, Blanche says",
     "source": {"domain": "cbsnews.com"}, "published_at": "2026-09-15T22:20:23.000Z"}
  ]
}

Add category.id=medtop:04000000 (business, IPTC media topic) and it stops working:

{"status":"not_ok","errors":[{"status":500,"code":"ER0183","message":"Something went wrong."}]}

Five attempts, five failures: three HTTP 500 within 0.3 s, two HTTP 502 after a 30-second wait. source.country.code on the same endpoint also gave 500. language.code, per_page, fl, title and published_at.end were fine. So the front page comes from /top-headlines, and the category tabs are assembled from /everything. Unlike /top-headlines, /everything returns whatever matched, newest first, with no editorial ranking, which means the tabs need a source-rank floor and a topic rule before they look like a front page:

/v1/news/everything
  ?language.code=en
  &category.id=medtop:04000000
  &source.rank.opr.min=8        # big outlets only
  &is_duplicate=0               # one copy of each story
  &sort.by=published_at&sort.order=desc
  &per_page=16                  # 8 candidates per slot shown
  &fl=title,source.domain,published_at,categories

source.rank.opr.min is an Open PageRank floor. At 8 the business tab over the last 24 hours (16 Sep 07:00 to 17 Sep 07:00 UTC) had 86 articles from the Guardian, CBS, TechCrunch and CNET. Sport had 29. Science & tech had 8 — the panel would have redrawn the same two lines all day. Dropping that tab to source.rank.opr.min=7 gave 110 articles, but 27 of them (25%) were dev.to posts, because dev.to ranks high and gets tagged as technology. ignore.source.domain=dev.to brought it to 83 from independent.co.uk, sciencedaily.com, gizmodo.com and space.com. That tab is science-heavy (medtop:13000000 is "science and technology"), so the label on the board says SCIENCE & TECH.

One more filter, and it is the weak spot. Each article carries categories[] with a score per category, and the tagger is generous: over the same 24 hours the Guardian's "Thursday news quiz" was tagged Business at 0.3 and Sport at 0.46, a Snap Specs review was Sport at 1.03, and six Guardian film reviews sat under Business at exactly 2.0. The score alone doesn't separate them — a $18M funding round scored 1.31 for Business, below the film reviews.

What worked best of the rules we tried: keep an article only if the tab's category out-scores every other category on it and reaches 1.0. On the 86 business articles that keeps 32, and 26 of those are business by our reading (81%); the unfiltered list was 50/50. It keeps 19 of 29 sport and 20 of 83 science & tech, so the script fetches eight candidates per slot to have enough left. Expect roughly one tab line in five to be off-topic anyway. In the frame below it's two of six: a Nicolas Winding Refn interview under Business and a partisan book review under Science & tech.

Nine headlines fit at 18 px, not ten

E-paper is 1-bit: no grey, no anti-aliasing to hide behind. Before choosing a font size we rendered the 256 unique headlines from the 24-hour sample (median 73 characters) with Pillow in DejaVu Sans, at 768 px of text width, and counted lines.

Font size	Fits on one line	Needs two lines	Needs three
17 px	85%	15%	0%
18 px	75%	25%	0%
19 px	71%	29%	0%
20 px	54%	46%	0%
22 px	35%	65%	0.4%

Then the same test with a 150 px source column on the right (618 px for text): at 18 px only 34% fit on one line. The column costs about three headlines per screen. So sources went into a footer line and headlines got the full width.

The pixel budget at 18 px: header 32 px, four section labels at 20 px, a footer line, 21 px per text line (DejaVu 18 px is 17 px ascent plus 5 descent) and 4 px between headlines. Nine one-line headlines use 416 px of the 480; every wrapped one adds 21 px, so the board fits up to four two-liners. We replayed the 24 reconstructed screens through the renderer: in 22 hours all nine fit, in 2 the last sport headline was dropped rather than drawn over the footer. Ten headlines did not fit in any layout we tried.

This is the 1-bit PNG the script produces with --preview; the panel shows exactly this.

The script

One file, 142 lines. Run it with --preview out.png on a laptop and it writes the frame instead of touching the panel; on the Pi it imports the Waveshare driver and draws.

#!/usr/bin/env python3
"""Headlines on a Waveshare 7.5" e-paper (800x480). Runs once and exits;
cron calls it every hour. `--preview out.png` renders without the panel.
"""
import os
import sys
import time
import datetime as dt

import requests
from PIL import Image, ImageDraw, ImageFont

API = "https://api.apitube.io/v1/news"
KEY = os.environ["APITUBE_API_KEY"]
W, H = 800, 480
FONT_DIR = os.environ.get("FONT_DIR", "/usr/share/fonts/truetype/dejavu")

COMMON = {"language.code": "en", "fl": "title,source.domain,published_at,categories"}
# top-headlines is already limited to high-authority sources; the category
# tabs get the same treatment by hand: big outlets only, no duplicates, newest first.
BIG = {"source.rank.opr.min": 8, "is_duplicate": 0,
       "sort.by": "published_at", "sort.order": "desc"}
# Science & tech at OPR 8+ is only ~8 articles a day, so that tab goes one
# notch lower and drops dev.to, which otherwise takes a quarter of the slots.
TECH = dict(BIG, **{"source.rank.opr.min": 7, "ignore.source.domain": "dev.to"})

# (label, endpoint, params, headlines to show)
TABS = [
    ("TOP STORIES", "top-headlines", {}, 3),
    ("BUSINESS", "everything", dict(BIG, **{"category.id": "medtop:04000000"}), 2),
    ("SCIENCE & TECH", "everything", dict(TECH, **{"category.id": "medtop:13000000"}), 2),
    ("SPORT", "everything", dict(BIG, **{"category.id": "medtop:15000000"}), 2),
]


def on_topic(article, cat):
    """Keep an article only if the tab's category out-scores every other
    category on it and reaches 1.0. The tagger alone is not enough: it puts
    a Guardian film review under Business at 2.0 and a news quiz under Sport."""
    cats = article.get("categories") or []
    mine = [c["score"] for c in cats if c["links"]["self"].endswith("/" + cat)]
    others = [c["score"] for c in cats if not c["links"]["self"].endswith("/" + cat)]
    return bool(mine) and mine[0] >= 1 and all(o < mine[0] for o in others)


def fetch(endpoint, params, n, seen):
    r = requests.get(f"{API}/{endpoint}", params=dict(COMMON, per_page=8 * n, **params),
                     headers={"X-API-Key": KEY}, timeout=30)
    r.raise_for_status()
    out = []
    for a in r.json()["results"]:
        if a["title"] in seen:
            continue                           # same story already on screen
        if "category.id" in params and not on_topic(a, params["category.id"]):
            continue
        seen.add(a["title"])
        out.append(a)
        if len(out) == n:
            break
    return out


def font(size, bold=False):
    name = "DejaVuSans-Bold.ttf" if bold else "DejaVuSans.ttf"
    return ImageFont.truetype(os.path.join(FONT_DIR, name), size)


def wrap(draw, text, fnt, max_w, max_lines=2):
    """Greedy word wrap into at most max_lines; ellipsis if the text ran over."""
    lines, line = [], ""
    for word in text.split():
        trial = f"{line} {word}".strip()
        if draw.textlength(trial, font=fnt) <= max_w:
            line = trial
            continue
        lines.append(line)
        line = word
        if len(lines) == max_lines:
            break
    else:
        lines.append(line)
        return lines
    while draw.textlength(lines[-1] + "…", font=fnt) > max_w:
        lines[-1] = lines[-1].rsplit(" ", 1)[0]
    lines[-1] += "…"
    return lines


def render(sections, now):
    img = Image.new("1", (W, H), 255)          # 1-bit: 0 = black, 255 = white
    d = ImageDraw.Draw(img)
    f_head, f_label, f_item, f_foot = font(20, True), font(14, True), font(18), font(13)
    LINE, GAP = 21, 4                          # 18 px DejaVu is 17 px ascent + 5 descent

    d.rectangle((0, 0, W, 32), fill=0)
    d.text((16, 5), now.strftime("%a %d %b  %H:%M"), font=f_head, fill=255)
    d.text((W - 16, 5), "headlines", font=f_head, fill=255, anchor="ra")

    y, floor, sources, dropped = 38, H - 22, [], 0   # floor: keep clear of the footer
    for label, items in sections:
        d.text((16, y), label, font=f_label, fill=0)
        d.line((16, y + 17, W - 16, y + 17), fill=0)
        y += 20
        for a in items:
            lines = wrap(d, a["title"], f_item, W - 32)
            if y + LINE * len(lines) > floor:
                dropped += 1                   # too many two-liners this hour
                continue
            for ln in lines:
                d.text((16, y), ln, font=f_item, fill=0)
                y += LINE
            y += GAP
            sources.append(a["source"]["domain"])
        y += 6

    seen = list(dict.fromkeys(sources))        # unique, in order
    d.text((16, H - 18), "Sources: " + ", ".join(seen), font=f_foot, fill=0)
    return img, dropped


def main():
    now = dt.datetime.now()
    seen = set()
    sections = [(label, fetch(ep, params, n, seen)) for label, ep, params, n in TABS]
    img, dropped = render(sections, now)
    if dropped:
        print(f"{now:%H:%M} dropped {dropped} headline(s) that did not fit")

    if len(sys.argv) > 2 and sys.argv[1] == "--preview":
        img.save(sys.argv[2])
        return

    from waveshare_epd import epd7in5_V2       # only importable on the Pi
    epd = epd7in5_V2.EPD()
    epd.init()                                 # full refresh: no ghosting
    epd.display(epd.getbuffer(img))
    time.sleep(2)
    epd.sleep()                                # panel holds the image unpowered


if __name__ == "__main__":
    main()

Notes on the parts that aren't obvious:

Image.new("1", ...) makes a 1-bit image. epd.getbuffer() packs it for the panel; you never convert.
wrap() is a greedy word wrap capped at two lines with an ellipsis. Pillow's textlength() is what makes the layout table above true on the device.
fetch() asks for 8 * n results, drops anything already on screen (the news quiz showed up under two tabs at once) and anything that fails on_topic(), then keeps n.
render() refuses to draw a headline that would run into the footer and reports it on stdout, which cron writes to the log.
The API key comes from the environment. Don't put it in the file; cron can pass it.

Cron and being kind to the panel

Setup on the Pi, once:

sudo raspi-config → Interface Options → SPI → enable.
sudo apt install python3-pil python3-numpy python3-requests fonts-dejavu
git clone https://github.com/waveshare/e-Paper and point PYTHONPATH at e-Paper/RaspberryPi_JetsonNano/python/lib, or copy the waveshare_epd folder next to the script.
python3 headlines_eink.py --preview test.png first. If the PNG looks right, run it without the flag.

Then the cron line (crontab -e):

0 * * * * APITUBE_API_KEY=your_key PYTHONPATH=/home/pi/e-Paper/RaspberryPi_JetsonNano/python/lib /usr/bin/python3 /home/pi/headlines_eink.py >> /home/pi/headlines.log 2>&1

Two habits keep the panel healthy. The script calls epd.init() before every draw, which is a full refresh — the whole screen flashes black and white for a few seconds and ghosting from the previous frame is gone. The driver also has init_part() and display_Partial() for updating a region without the flash; we don't use them, because at one redraw an hour the flash doesn't matter and full refreshes are what clear ghosting. After drawing, epd.sleep() powers the panel down; e-paper holds the image with no power, so between refreshes the HAT draws nothing. Waveshare's wiki is explicit that e-paper isn't meant for continuous refreshing, which is the other reason hourly is the right cadence.

How often does the board actually change?

Hourly was a guess. To check it we reconstructed what the board would have shown at each full hour over 24 hours (16 Sep 08:00 to 17 Sep 07:00 UTC) by calling each endpoint with published_at.end set to that hour, then counted how many of the on-screen headlines were new compared with the hour before. One caveat: /top-headlines ranks as the API sees it today, restricted to articles that existed at that hour — a reconstruction, not a log we kept live.

Section (lines)	New lines per hour	Hours with no change (of 23)
Top stories (3)	0.83	8
Business (2)	0.96	8
Science & tech (2)	0.74	10
Sport (2)	0.61	11
Whole board (9)	3.13	2

So an hourly redraw replaces about a third of the board. Science & tech was thin even after the OPR change: in 9 of the 24 hours fewer than two of the twelve candidates we fetched passed the topic rule, which is why the script fetches sixteen.

The refresh cadence follows from that. Redrawing every 2 hours would show 5.09 new lines per refresh, every 3 hours 6.71, every 6 hours 8 of 9 — at which point the board is a different board each time and you've lost the point of glancing at it. We kept hourly: 3 new lines per glance is enough to be worth looking, and in only 2 of 23 hours would the flash have been for nothing. If the full-refresh flash bothers you at your desk, every 3 hours is the next sensible setting, not every 15 minutes.

For latency, the 24 front-page calls took a median of 3.53 s from a laptop (min 2.14 s, p90 5.04 s, max 6.36 s); the category calls took 8–10 s each. None of it matters at one run an hour.

FAQ

How do you display news headlines on a Raspberry Pi e-ink screen?
The simplest way to display news headlines on a Raspberry Pi e-ink screen is a Python script that fetches titles from a news API, draws them into a 1-bit Pillow image the size of the panel (800×480 for the Waveshare 7.5" V2) and pushes it with the vendor driver — epd.init(), epd.display(epd.getbuffer(img)), epd.sleep() — because the panel accepts nothing but a packed bitmap. The script above is the whole thing.

How often can you refresh an e-paper display?
The right refresh rate for an e-paper news display is once an hour, because the vendor advises against continuous refreshing and the news doesn't move faster than that: in our 24-hour sample the top three headlines changed 0.83 times per hour and the nine-line board 3.13 lines per hour. A full refresh on the Waveshare 7.5" V2 takes a few seconds; partial refresh is faster but leaves ghosting.

Can a Raspberry Pi Zero 2 W drive a 7.5-inch e-paper?
A Raspberry Pi Zero 2 W should drive the 7.5-inch Waveshare HAT, because the HAT uses SPI on the standard 40-pin header and the script needs only requests and Pillow. We ran ours on a Pi 4 and did not test a Zero 2 W.

How do you run a Python script every hour on a Raspberry Pi?
The standard way to run a Python script every hour on a Raspberry Pi is a cron line — 0 * * * * /usr/bin/python3 /home/pi/headlines_eink.py — because cron is already installed and survives reboots. Put environment variables (the API key, PYTHONPATH) on the same line and redirect output to a log file so failures are visible.

Which Waveshare e-paper is best for a headlines board?
The best Waveshare e-paper for a headlines board is the 7.5" black-and-white V2 (800×480), because nine headlines fit at 18 px and a black-and-white panel does a full refresh in seconds. We didn't test the three-colour variants or the smaller panels; scale the layout table above by their pixel height before buying.

Disclosure

We work on APITube, and it is the API in this post — free tier at apitube.io. Any API that returns titles as JSON works with the script; only fetch() changes.

Resources

Waveshare e-Paper driver and examples: https://github.com/waveshare/e-Paper
APITube API reference: https://docs.apitube.io
IPTC Media Topics (the medtop: ids): https://iptc.org/standards/media-topics/
Pillow ImageDraw: https://pillow.readthedocs.io/en/stable/reference/ImageDraw.html

One news bot for Bluesky and X, and why X gets only five posts a day

APITube News API — Fri, 02 Oct 2026 05:09:04 +0000

One news bot for Bluesky and X, and why X gets only five posts a day

X charges $0.200 for every post that contains a URL. Bluesky charges nothing. That one line from the X pricing page decides the shape of a twitter news bot in Python in 2026: it posts every story to Bluesky and only the best few to X, and "best" has to be a number the script can check. We built that bot for one industry feed, measured the feed for a day, and ran the script on a 30-minute GitHub Actions schedule. One day of Renewable Energy news came to 270 articles; after the filters the bot actually wants, 5 of them were worth $0.200 each.

A news bot, as built here, is a script that pulls fresh articles from a news API, drops the ones it has already posted, and publishes the rest to Bluesky and X on a schedule with no server of its own. This post is for developers and marketers who want one that runs unattended: one Python file, one workflow file, one state file. Everything below ran on 2026-09-17 with Python 3.12, atproto 0.0.72, tweepy 4.17.0 and Pillow 12.3.0. The feed came from the APITube news API; the numbers come from the CSVs published next to this post.

Takeaways

X: $0.015 per post, $0.200 per post with a URL, no free tier. Bluesky: $0.
One day of one industry: 270 articles → 252 unique headlines → 35 with a share image → 5 from sources ranked 6 or higher.
is_duplicate=0 and href dedupe removed 0 of the 270; normalising titles removed 18.
Of 29 share images fetched, 5 were over Bluesky's 1,000,000-byte blob limit and 6 were smaller than 1200×630 despite the filter.
Posting all 34 stories a day to X costs $204 a month; posting the top 5 costs $30.

What the bot does

Every 30 minutes a GitHub Actions job runs bot.py, and each run does five things:

Asks the news API for the last 24 hours of one industry, share-image articles only.
Drops anything whose normalised title or URL is already in posted.json.
Posts up to three new stories to Bluesky, each with a link card and a thumbnail under 1,000,000 bytes.
Sends the ones whose source ranks 6 or higher to X as well.
Writes what it posted back to posted.json, which the workflow commits so the next run remembers.

The one rule that matters: a story goes to X only if its source has an OpenPageRank of 6 or more (X_MIN_OPR = 6). Everything else goes to Bluesky only. That threshold is the difference between a $204 and a $30 monthly bill, and it comes from the feed's own numbers, not from taste.

Step 1. Pick a feed and measure it before you post it

The bot filters on industry.id. Industry ids come from GET /v1/suggest/industries?prefix=renew, which returned 367 Renewable Energy among others. We pulled every English article tagged with it for 16 September 2026 UTC and ran the filters the bot would run.

Filter stage (Sep 16, `industry.id=367`, `language.code=en`)	Articles
Raw	270
Unique by `href`	270
Unique by normalised title	252
`has_social_share_image=1`	35
+ unique title	34
+ `source.rankings.opr >= 5`	23
+ `source.rankings.opr >= 6`	5

One day, 16 September 2026 UTC, industry.id=367, English only; each stage is a filter the bot applies, counted from the same 270-row pull (data.csv).

Two things in that table surprised us. First, the deduplication most bots rely on did nothing: all 270 hrefs were distinct and is_duplicate was false on all 270. Syndicated stories arrive with different URLs on different domains. Lowercasing the title and stripping punctuation found 18 copies, including one story ("Egypt's wind power push…") published six times. Title normalisation is the dedupe that matters; the flag and the URL are not.

Second, the image filter is doing most of the work. has_social_share_image=1 is meant to keep articles with an image of at least 1200×630, the size a Bluesky link card or an X card renders well, and it cut 270 to 35. The other candidates we counted the same day: is_high_quality=1 53, is_twitter_card_ready=1 52, has_hq_images=1 41, has_image=1 147. A bot posting 147 stories a day is spam; 35 is a feed.

Arrivals are lumpy. Over the raw 270 the busiest 30-minute slot had 21 articles and the median slot 4, which is why the script caps posts per run rather than posting whatever arrived.

Step 2. The script, part one: fetch, dedupe, thumbnails

The whole bot is one file. This first half talks to the news API and prepares the image; no social network is involved yet.

"""Post fresh industry news to Bluesky and X. Runs once, exits. Cron does the looping."""
import datetime as dt
import io
import json
import os
import re
import sys

import requests
from PIL import Image

API = "https://api.apitube.io/v1/news/everything"
STATE_FILE = "posted.json"
INDUSTRY_ID = os.environ.get("INDUSTRY_ID", "367")        # 367 = Renewable Energy
MAX_PER_RUN = int(os.environ.get("MAX_PER_RUN", "3"))
X_MIN_OPR = int(os.environ.get("X_MIN_OPR", "6"))          # X costs money per post; only the best go there
DRY_RUN = os.environ.get("DRY_RUN") == "1"


def fetch_recent(hours=24):
    since = dt.datetime.now(dt.timezone.utc) - dt.timedelta(hours=hours)
    r = requests.get(API, headers={"X-API-Key": os.environ["APITUBE_API_KEY"]}, timeout=30, params={
        "industry.id": INDUSTRY_ID, "language.code": "en",
        "published_at.start": since.strftime("%Y-%m-%dT%H:%M:%SZ"),
        "has_social_share_image": 1, "is_duplicate": 0,
        "sort.by": "published_at", "sort.order": "desc", "per_page": 50,
        "fl": "id,href,title,published_at,image,media,source.domain,source.rankings.opr",
    })
    r.raise_for_status()
    return r.json()["results"][::-1]                      # oldest first, so posts come out in order


def title_key(title):
    return " ".join(re.sub(r"[^a-z0-9 ]", "", title.lower()).split())


def image_url(article):
    if article.get("image"):
        return article["image"]
    return next((m["url"] for m in article.get("media") or [] if m.get("type") == "image"), None)


def fetch_thumb(url, cap=1_000_000):
    """Bluesky rejects blobs over 1,000,000 bytes; shrink anything bigger."""
    data = requests.get(url, timeout=20, headers={"User-Agent": "industry-news-bot/0.1"}).content
    if len(data) <= cap:
        return data
    im = Image.open(io.BytesIO(data)).convert("RGB")
    im.thumbnail((1200, 1200))
    buf = io.BytesIO()
    im.save(buf, "JPEG", quality=85)
    return buf.getvalue()

fl= trims each article to eight fields; without it every result carries the full body, entities and media list. image_url() exists because 6 of the 35 articles that passed the share-image filter had no image field at all; the picture was in media[] with type: "image". fetch_thumb() exists because of the other 29: median size 293,840 bytes, largest 2,717,236, and 5 of them over the 1,000,000-byte limit Bluesky enforces on uploaded blobs. Pillow's thumbnail((1200, 1200)) plus JPEG quality 85 brought those five down to between 129,764 and 250,145 bytes. Fetching an image took a median of 717 ms and a maximum of 2,544 ms, which is where most of a run's wall time goes.

One number we cannot fix in code: 6 of the 29 images were smaller than 1200×630 (650×475 and 1000×667 among them) even though the filter promises that size. The card still renders; it just renders smaller. If exact dimensions matter to you, check im.size after opening and skip the card.

Step 3. The script, part two: Bluesky and X

Bluesky wants a rich-text post plus an "external" embed for the link card. TextBuilder writes the title, then the domain as a clickable facet, so the visible text stays short and the 300-grapheme limit is never close: the longest title in the sample was 118 characters, the median 77. X wants plain text; a URL counts as 23 characters regardless of length, so every title in the sample fits in 280 as well.

def bluesky_client():
    from atproto import Client
    client = Client()
    client.login(os.environ["BSKY_HANDLE"], os.environ["BSKY_APP_PASSWORD"])
    return client


def post_bluesky(client, article, thumb):
    from atproto import client_utils, models
    text = client_utils.TextBuilder().text(article["title"] + "\n").link(article["source"]["domain"], article["href"])
    blob = client.upload_blob(thumb).blob if thumb else None
    card = models.AppBskyEmbedExternal.External(uri=article["href"], title=article["title"], description="", thumb=blob)
    client.send_post(text, embed=models.AppBskyEmbedExternal.Main(external=card), langs=["en"])


def x_client():
    import tweepy
    return tweepy.Client(
        consumer_key=os.environ["X_API_KEY"], consumer_secret=os.environ["X_API_SECRET"],
        access_token=os.environ["X_ACCESS_TOKEN"], access_token_secret=os.environ["X_ACCESS_SECRET"],
    )


def post_x(client, article):
    client.create_tweet(text=f'{article["title"]} {article["href"]}')  # a URL counts as 23 chars on X

Bluesky credentials are a handle and an app password, created under Settings → App Passwords; never use the account password. X credentials are the four OAuth 1.0a strings from a developer app with read-and-write permission, and the app has to be attached to a project with purchased credits, because there is no free tier to fall back on.

Step 4. The main loop, and what a dry run prints

def main():
    state = json.load(open(STATE_FILE)) if os.path.exists(STATE_FILE) else {"titles": [], "hrefs": []}
    seen_titles, seen_hrefs = set(state["titles"]), set(state["hrefs"])

    fresh = [a for a in fetch_recent() if title_key(a["title"]) not in seen_titles and a["href"] not in seen_hrefs]
    batch, keys = [], set()
    for a in fresh:                                      # same story from two domains -> post once
        k = title_key(a["title"])
        if k not in keys:
            keys.add(k)
            batch.append(a)
    batch = batch[:MAX_PER_RUN]
    print(f"fetched {len(fresh)} unseen, posting {len(batch)}")

    bsky = None if DRY_RUN else bluesky_client()
    x = None if DRY_RUN else x_client()
    for a in batch:
        opr = (a.get("source", {}).get("rankings") or {}).get("opr") or 0
        url = image_url(a)
        thumb = fetch_thumb(url) if url else None
        to_x = opr >= X_MIN_OPR
        print(f"[{'dry' if DRY_RUN else 'post'}] bsky{' + x' if to_x else ''} | opr {opr} | thumb {len(thumb) if thumb else 0} B | {a['title'][:70]}")
        if not DRY_RUN:
            post_bluesky(bsky, a, thumb)
            if to_x:
                post_x(x, a)
        state["titles"].append(title_key(a["title"]))
        state["hrefs"].append(a["href"])

    state["titles"], state["hrefs"] = state["titles"][-2000:], state["hrefs"][-2000:]
    json.dump(state, open(STATE_FILE, "w"), indent=0)


if __name__ == "__main__":
    sys.exit(main())

Three consecutive runs with DRY_RUN=1, about 04:59 UTC:

fetched 33 unseen, posting 3
[dry] bsky | opr 4 | thumb 601276 B | Chongqing, Spain's Extremadura Deepen Ties in EVs and Green Energy
[dry] bsky | opr 3 | thumb 55318 B | Egypt's Wind Turbine Manufacturing Push: A New Blueprint for Africa's
[dry] bsky | opr 4 | thumb 152741 B | Heathrow expansion incompatible with climate targets, advises UK gover
fetched 30 unseen, posting 3
...
fetched 27 unseen, posting 3
[dry] bsky | opr 5 | thumb 956337 B | Elcogen and Shanghai HyEnergy advance collaboration on commercial depl

The runs took 5.4 s, 3.0 s and 3.1 s, and posted.json ended with 9 titles. The "unseen" count drops by three each run because the state file works; none of the nine reached the opr 6 bar, so none would have gone to X. What ran live here is the fetch, dedupe and thumbnail path. The Bluesky and X calls were exercised against the SDK signatures (login + send_post, create_tweet) but not against real accounts from this run; do your first real run with MAX_PER_RUN=1 and look at the result before letting the cron loose.

Step 5. Every 30 minutes on GitHub Actions

name: industry-news-bot
on:
  schedule:
    - cron: "*/30 * * * *"
  workflow_dispatch:
permissions:
  contents: write
jobs:
  post:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install requests pillow atproto tweepy
      - run: python bot.py
        env:
          APITUBE_API_KEY: ${{ secrets.APITUBE_API_KEY }}
          BSKY_HANDLE: ${{ secrets.BSKY_HANDLE }}
          BSKY_APP_PASSWORD: ${{ secrets.BSKY_APP_PASSWORD }}
          X_API_KEY: ${{ secrets.X_API_KEY }}
          X_API_SECRET: ${{ secrets.X_API_SECRET }}
          X_ACCESS_TOKEN: ${{ secrets.X_ACCESS_TOKEN }}
          X_ACCESS_SECRET: ${{ secrets.X_ACCESS_SECRET }}
      - run: |
          git config user.name "news-bot"
          git config user.email "news-bot@users.noreply.github.com"
          git add posted.json
          git commit -m "state: $(date -u +%FT%TZ)" || exit 0
          git push

The last step is the part most schedule-a-bot posts skip. A GitHub Actions runner is a fresh machine every time, so the state has to live somewhere; committing posted.json back to the repository is the zero-infrastructure answer, and permissions: contents: write is what lets the default token push. || exit 0 keeps a run with nothing new from failing on an empty commit.

Does 30 minutes fit the feed? We replayed 16 September through the same cap: with the 34 post-filter stories arriving at their real timestamps, 23 of the 48 runs would have posted nothing, no run would have hit the 3-post cap, the busiest slot had 2 arrivals, and nothing was left in the backlog at midnight. If your industry is busier, raise MAX_PER_RUN before you shorten the interval. GitHub documents that scheduled runs can be delayed under load and that the cron floor is 5 minutes, so a late run is normal and the 24-hour fetch window plus the state file means a late run posts what a missed one would have.

What X costs at this volume

The X pricing page lists "Post: Create" at $0.015 per request and "with URLs" at $0.200 per request, pay-per-use, no subscription and no free tier. A news bot posts URLs. Multiply by the feed:

Sent to X per day	Per day	Per month (30 days)	Bluesky
All 34	$6.80	$204	$0
Sources with `opr >= 5` (23)	$4.60	$138	$0
Sources with `opr >= 6` (5)	$1.00	$30	$0
All 34, no URL in the post	$0.51	$15.30	$0

Daily counts from the Sep 16 funnel × $0.200 per URL post × 30 days; Bluesky posting is free, so its bar is zero in every row.

That table is the whole argument for X_MIN_OPR. Unlike Bluesky, which bills nothing per post, X bills $0.200 for every post with a link, which means the filter in front of X is a budget line and the filter in front of Bluesky is only a taste question. The feed already carries a source rank on every article, so the script spends $0.200 only where a well-ranked domain is behind the headline and puts the rest on the network where the same post is free. Dropping the URL to hit the $0.015 rate is the cheaper-looking row, but a news post without a link is a headline nobody can act on. If you would rather pick by topic than by rank, the same gate works on anything in the article: is_breaking, a sentiment score, an entity name.

Where this leaves you

A news bot in 2026 is a filter with a budget attached. The script above is the filter: one industry, share images only, titles deduped, three posts per run, every run remembered. The budget is the one line from the X pricing page, and the feed's own source rank is what turns it into $30 a month instead of $204 while Bluesky gets all 34 stories for nothing. Copy bot.py and bot.yml, set the seven secrets, run once with MAX_PER_RUN=1, then let the cron take over.

FAQ

Is the X (Twitter) API free for bots?

The X API is not free for bots, because as of the current pricing page it is pay-per-use with credits bought in the developer console and the earlier Free, Basic and Pro tiers are gone. A bot that posts links pays $0.200 per post. Reading is billed separately.

How much does it cost to post a link with the X API?

The cost to post a link with the X API is $0.200 per request, against $0.015 for a post without a URL, because the X API pricing page prices "Post: Create" and "with URLs" as two different rates. For this feed that is $204 a month for all 34 daily stories, or $30 a month for the 5 from sources ranked 6 or higher.

Can you make a news bot on Bluesky?

A news bot on Bluesky is possible and free, because posting through the AT Protocol costs nothing and needs only a handle plus an app password. Log in through the atproto package, build the text with TextBuilder so the link is a facet, upload the thumbnail with upload_blob (under 1,000,000 bytes), and call send_post with an AppBskyEmbedExternal embed for the link card.

How do I schedule a Python bot for free?

The free way to schedule a Python bot is a GitHub Actions workflow with on: schedule: cron: "*/30 * * * *", because it runs the script on a fresh runner every 30 minutes at no cost for a public repository and within the free minutes for a private one. Keep state by committing a small JSON file back to the repository at the end of each run; runs can be delayed under load, so keep the fetch window wider than the interval.

Is Tweepy still working in 2026?

Tweepy still works in 2026, because tweepy 4.17.0 wraps the X API v2 and tweepy.Client(...).create_tweet(text=...) posts as before. What changed is the bill behind it: every call goes through the pay-per-use X API, so Tweepy is free and the request it makes is not.

Resources

X API pricing: https://docs.x.com/x-api/getting-started/pricing
atproto Python SDK: https://atproto.blue
Tweepy documentation: https://docs.tweepy.org
APITube /v1/news/everything reference (industry, image and duplicate filters): https://docs.apitube.io/platform/news-api/everything
GitHub Actions scheduled events: https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#schedule
Scripts and CSVs behind every number here: bot.py, bot.yml, pull_day.py, data.csv (the 270 articles), funnel.csv, images.csv, slots.csv in ./images/11-industry-news-bot-bluesky-x/

APITube is the news API used above — free tier at apitube.io.

Disclosure: we work on APITube. The feed measurements were taken with an APITube key against the public API on 2026-09-17; X prices are quoted from the X pricing page on the same day and may change.

A CrewAI crew writes our daily pharma brief for three cents

APITube News API — Wed, 30 Sep 2026 17:49:06 +0000

A CrewAI crew writes our daily pharma brief for three cents

One daily Pharma brief from a three-agent CrewAI crew costs $0.030 on Claude Haiku 4.5 when the tool hands the model the news API's key sentences: 14,452 prompt tokens, 3,042 completion tokens, 4 LLM calls, 8 stories with 8 real links. The same crew on headlines alone costs $0.018 and writes a brief with 1.3 numbers in it; on full article bodies it costs $0.067 and the brief is not more specific (6.3 numbers against 9.0). We ran each configuration three times on the same 40 articles, and this post is the crew, the tool, and the bill.

A CrewAI news agent is a crew of role-playing agents in which one agent owns a tool that fetches articles and the others turn its notes into a document. This post is for people who build agents in Python and want a brief that arrives every morning with a known cost. The industry is Pharma because it is busy (311 English articles tagged Pharma in the 24 hours we used) and because a pharma analyst is a real reader; swap one id and it is any industry. Everything was run on 2026-09-17 with CrewAI 1.15.22; the code, the 12 briefs, the per-call token log and the article snapshot sit next to this post.

Takeaways

Key sentences (summary[]) instead of full bodies: 14,452 prompt tokens instead of 53,378, $0.030 instead of $0.067 per brief, and 9.0 specific numbers in the brief instead of 6.3.
Headlines only are cheapest at $0.018, but the brief has 1.3 numbers in it and the writer fills the gap with significance it made up.
12 runs, 12 drafts, 0 invented URLs: all 8 links in every draft, 96 in total, were URLs the tool had returned. The editor's job turned out to be cutting, not fact-checking: 181 → 151 words, 24 → 21 links on headlines.
The researcher reads 63% of the tokens on headlines, 79% on key sentences and 94% on bodies. The writer and editor never see an article.
Share one LLM object between three agents and crew.usage_metrics reports 19,713 prompt tokens for a run that used 6,571. One object per agent.
Claude Sonnet 4.6 on the same key sentences: $0.096 a brief, 8.0 numbers. No gain here.

Step 1. Pick the beat and the fields, not the whole feed

The crews in most CrewAI tutorials search the web and hand the model whatever comes back. Ours calls one endpoint with one industry id, so the corpus is fixed and countable. APITube tags every article with industries; GET /v1/suggest/industries?prefix=pharma returns 819 Pharma among others, and the 24 hours from 2026-09-16 06:00 UTC held 311 English articles with that tag.

The other decision is fl=, the field list. An article's body is 4,202 characters at the median and 57,716 at the longest in this day's set; its summary is five key sentences with a sentiment score each, about 781 characters. We ask for both so the tool can hand the model either.

curl -s "https://api.apitube.io/v1/news/everything?industry.id=819&language.code=en&is_duplicate=0&published_at.start=2026-09-16T06:00:00Z&sort.by=published_at&sort.order=desc&per_page=200&fl=id,title,href,source.domain,published_at,summary,body" \
  -H "X-API-Key: $APITUBE_API_KEY"

One result, cut to two of its five key sentences (the first one in this article is a broken line from a financial table, which is what a summary extractor gives you on a press release; the model coped):

{
  "title": "Innate Pharma Reports First Half 2026 Business Update and Financial Results – CIOCoverage- Driven for Technology Leaders",
  "href": "https://www.ciocoverage.com/innate-pharma-reports-first-half-2026-business-update-and-financial-results/",
  "source": {"domain": "ciocoverage.com"},
  "published_at": "2026-09-17T05:22:07.000Z",
  "summary": [
    {"sentence": "“2026 continues to be an important year of execution for Innate, marked by our strategic partnership with Sobi and the strengthening of our financial position,”said Jonathan Dickinson, CEO of Innate Pharma.",
     "sentiment": {"score": 0.13, "polarity": "positive"}},
    {"sentence": "“With the TELLOMAK-3 Phase 3 study initiated, we are targeting the first patient in the study in Q1 2027 as we work toward a filing for accelerated approval in Sézary syndrome.",
     "sentiment": {"score": 0.06, "polarity": "positive"}}
  ],
  "body": "..."
}

Step 2. The tool: one call, three renderings

The tool takes no arguments. It fetches the last 24 hours, keeps the 40 newest articles with at most two per site (stocknews.com alone had 16 that day), and renders them in one of three modes set by NEWS_MODE. Everything else in the crew stays the same, which is what makes the three modes comparable.

# brief_crew.py (excerpt)
import datetime as dt, os, requests
from collections import Counter
from crewai.tools import tool

INDUSTRY_ID = int(os.environ.get("INDUSTRY_ID", "819"))
MAX_ARTICLES = int(os.environ.get("MAX_ARTICLES", "40"))

def fetch_articles():
    now = dt.datetime.now(dt.timezone.utc)
    r = requests.get("https://api.apitube.io/v1/news/everything",
        headers={"X-API-Key": os.environ["APITUBE_API_KEY"]},
        params={"industry.id": INDUSTRY_ID, "language.code": "en", "is_duplicate": 0,
                "published_at.start": (now - dt.timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ"),
                "sort.by": "published_at", "sort.order": "desc", "per_page": 200,
                "fl": "id,title,href,source.domain,published_at,summary,body"}, timeout=60)
    r.raise_for_status()
    return r.json()["results"]

def pick(articles, n, per_domain=2):
    seen, out = Counter(), []
    for a in articles:
        d = a["source"]["domain"]
        if seen[d] >= per_domain:
            continue
        seen[d] += 1
        out.append(a)
        if len(out) == n:
            break
    return out

def render(articles, mode):
    lines = []
    for i, a in enumerate(articles, 1):
        lines.append(f"{i}. {a['title']} — {a['source']['domain']}, {a['published_at'][11:16]} UTC\n   {a['href']}")
        if mode == "summary":
            lines += [f"   • {s['sentence']}" for s in a.get("summary") or []]
        elif mode == "body":
            lines.append("   " + (a.get("body") or "").replace("\n", " "))
    return "\n".join(lines)

@tool("industry_news")
def industry_news() -> str:
    """Every article about the industry from the last 24 hours: number, title,
    source site, time, URL and, depending on configuration, the key sentences
    or the full text. Call it once; it returns the same set within a run."""
    return render(pick(fetch_articles(), MAX_ARTICLES), os.environ.get("NEWS_MODE", "summary"))

For 40 articles the tool's output is 8,819 characters on headlines, 41,984 on key sentences and 222,931 on bodies. The docstring is the tool description the model reads, so "call it once" is in there, and in all 12 runs it was called once.

Step 3. Three agents, three tasks, one LLM object each

The crew is sequential: the researcher calls the tool and shortlists eight stories with their URLs, the writer turns the shortlist into a brief, the editor removes anything without a URL from the research notes. context=[research] is how a task sees an earlier task's output; the editor gets both the notes and the draft.

from crewai import Agent, Crew, Process, Task

MODEL = os.environ.get("MODEL", "anthropic/claude-haiku-4-5-20251001")

def build_crew(make_llm=lambda: MODEL):
    # One LLM object per agent: crew.usage_metrics sums each agent's counters,
    # so one object shared by three agents reports every call three times.
    researcher = Agent(role="Pharma news researcher",
        goal="Pick the 8 stories a pharma analyst must see today and keep the URL of each",
        backstory="You read the whole feed once and shortlist. You never invent a story or a link.",
        tools=[industry_news], llm=make_llm(), max_iter=5, verbose=False)
    writer = Agent(role="Brief writer",
        goal="Turn the shortlist into a brief a busy reader finishes in two minutes",
        backstory="You write one line per story: what happened, why it matters, then the source link.",
        llm=make_llm(), max_iter=3, verbose=False)
    editor = Agent(role="Brief editor",
        goal="Ship a brief in which every claim is traceable to a URL from the research notes",
        backstory="You cut anything without a source link and anything the notes do not support.",
        llm=make_llm(), max_iter=3, verbose=False)

    research = Task(agent=researcher,
        description="Call industry_news once. From what it returns, shortlist the 8 most consequential "
                    "stories for a pharma analyst (regulatory decisions, trial results, deals, safety, "
                    "pricing). Skip stock-picking pieces and duplicates of the same event.",
        expected_output="A numbered list of 8 items. Each item: headline, one sentence on why it "
                        "matters, and the exact URL from the tool output on its own line.")
    write = Task(agent=writer, context=[research],
        description="Write today's Pharma brief from the research notes. One short paragraph of 1–2 "
                    "sentences per story, ending with the story's URL as a markdown link. No intro, no outro.",
        expected_output="A markdown brief of at most 250 words with one link per story.")
    edit = Task(agent=editor, context=[research, write],
        description="Edit the draft. Remove any story whose URL does not appear in the research notes "
                    "and any fact the notes do not contain. Keep it under 200 words. Keep the markdown links.",
        expected_output="The final brief in markdown, under 200 words, every story ending with a link.")
    return Crew(agents=[researcher, writer, editor], tasks=[research, write, edit],
                process=Process.sequential, verbose=False)

The comment about one LLM object per agent is not style. Crew.calculate_usage_metrics() loops over the agents and adds each agent's llm.get_token_usage_summary() to the total. We ran the crew once with a single object passed to all three agents: it made 4 calls and used 6,571 prompt tokens; crew.usage_metrics reported successful_requests=12 and 19,713 prompt tokens, exactly 3.0×. Passing a model string, or calling a factory as above, gives each agent its own counter. The check is in shared_llm_check.txt.

Step 4. Kick off and print the bill

crew = build_crew()
result = crew.kickoff()
print(result.raw)                       # the brief
u = crew.usage_metrics
cost = u.prompt_tokens / 1e6 * 1.00 + u.completion_tokens / 1e6 * 5.00   # Haiku 4.5 list price
print(f"{u.successful_requests} LLM calls, {u.prompt_tokens:,} in, {u.completion_tokens:,} out, ${cost:.4f}")

result.tasks_output holds the three task outputs in order, so the research notes and the writer's draft are there next to the editor's final. That is where the link check below comes from: every URL in a draft or final is compared with the set of href values the tool returned in that run.

What one brief costs, measured

Twelve kickoffs, three per configuration, all replaying the same articles.json so the only variable is what the tool hands the model. Prices are Anthropic's list prices on 2026-09-17: $1 per million input and $5 per million output tokens for Claude Haiku 4.5, $3 and $15 for Claude Sonnet 4.6. Wall time is 33–43 seconds per brief on Haiku.

Tool hands the model	Prompt tokens	Completion tokens	Cost per brief (min–max)	Final brief, words	Numbers in the brief	Links verified
Headlines only	6,626	2,360	$0.018 ($0.0181–$0.0188)	151	1.3	21 of 21
Key sentences (`summary[]`)	14,452	3,042	$0.030 ($0.0284–$0.0307)	238	9.0	24 of 24
Full bodies	53,378	2,811	$0.067 ($0.0653–$0.0705)	188	6.3	22 of 22
Key sentences, Claude Sonnet 4.6	14,864	3,458	$0.096 ($0.0935–$0.1000)	236	8.0	24 of 24

Claude Haiku 4.5 unless stated; mean of 3 runs on the same 40 articles. "Numbers in the brief" counts figures outside URLs (counts, percentages, dollar amounts, dates) in the editor's final. "Links verified" sums unique URLs over the 3 finals that match an href the tool returned.

Every run made exactly 4 LLM calls: the researcher twice (once to decide to call the tool, once with the tool's output in front of it), the writer once, the editor once. No retries, no format errors, in 12 of 12. That is why the min–max band is under a cent wide in every configuration: the only thing that moves between runs is how long the model's answers are.

The researcher is the whole bill. Its second call carries the tool output: 3,700 prompt tokens on headlines, 10,930 on key sentences, 49,615 on bodies. The writer's prompt is 918–1,218 tokens and the editor's 1,537–2,074 in every mode, because they read the researcher's notes, not the articles. If you want a cheaper crew, the lever is what the tool returns, not the number of agents.

What the tool should hand the model

The same story in two briefs. From a headlines run: "Genentech's Lunsumio-based regimen achieved its Phase III primary endpoint in follicular lymphoma, advancing a new treatment option that strengthens competitive positioning in oncology." Nothing after the comma is in the headline; the writer was asked for "why it matters" and supplied it. From a key-sentences run: "showing statistically significant reduction in disease progression risk for relapsed/refractory patients, paving the way to convert accelerated approval to full approval and expand second-line indications." Every clause is in the article's five key sentences. Across the three key-sentence runs the briefs carried the $75 million Sobi deal, the Q1 2027 enrollment target, the PACIFIC-9 readout, the 139% rise in ADHD prescriptions and the 55 patients in the JAMA study; we checked each against the article text.

Full bodies did not buy more of that. The body-mode briefs averaged 6.3 numbers to the key-sentence briefs' 9.0, at 2.27× the cost. Three runs is not a large sample and the gap may be noise, but the direction is clear enough for a rule: the right input for a CrewAI news agent is the API's key sentences, not the article bodies, because the key-sentence brief carried 9.0 specific numbers for $0.030 and the body brief 6.3 for $0.067. In order of cost:

Headlines when a title is all the reader needs: a link list, $0.018 a brief, 6,626 prompt tokens.
Key sentences for a brief that states facts: $0.030, 14,452 prompt tokens, 9.0 numbers per brief.
Full bodies only when the writer must quote or the API has no summary, and with a cap on the count: $0.067, 53,378 prompt tokens, 49,615 of them in one call.

Unlike the srk.ai and LangChain tutorials, which hand the model raw search results and never count, this crew pays a predictable 14,452 prompt tokens per brief on key sentences (14,177–14,593 across the three runs), which means a month of daily briefs is $0.89 on key sentences, $0.55 on headlines and $2.02 on bodies.

What the editor actually changes

The editor was written as a fact-checker. In these 12 runs it did not need to be one: all 8 URLs in every draft, 96 across the 12 runs, matched an href the tool had returned, so there was nothing to remove for being invented. What it removed was length. Draft to final: 181 → 151 words and 24 → 21 links on headlines, 267 → 238 words and 24 → 24 links on key sentences, 218 → 188 words and 24 → 22 links on bodies. The 200-word cap it was told to enforce held in 6 of 12 finals; the longest final was 311 words.

It did earn its keep once, in an earlier batch of nine runs we kept in batch-1/. One writer draft carried https://www.fijanzen.ch/... for finanzen.ch, a one-letter slip inside a 148-character URL, and the editor's final had the correct link, restored from the research notes. That is the case for the third agent: not hallucinated stories, but copy errors in long strings, which a diff against the notes catches.

The stop sequence is doing more than you think

CrewAI drives tools for a model without native function calling through text: the agent writes Thought:, Action: industry_news, Action Input: {}, and CrewAI is supposed to stop generation at \nObservation:, run the tool, and paste the result in. It applies \nObservation: as a stop word on the agent's LLM for the duration of the run, and the API cuts generation there.

We ran the model through a backend without server-side stop sequences and cut the text ourselves, so we saw what the model writes when nobody stops it. Every one of the 12 first calls kept going past Action Input: {}. Haiku's ran to 131–475 tokens, of which CrewAI's cut kept 66–75; the rest was mostly a note that it was waiting for the tool. Sonnet 4.6's ran to 5,089–5,925 tokens and up to 19,356 characters: an Observation: containing a made-up feed, with an FDA approval of oral semaglutide and a reuters.com URL that appear nowhere in the day's 311 articles, and a complete final brief built on it. The cut kept 57–63 tokens of those calls, and the real tool output went in after it. If you ever swap in a provider that ignores stop, or you write your own BaseLLM.call(), that invented feed is what reaches your writer.

How we measured, and what is different from your setup

The machine that produced these numbers has a Claude Code subscription and no API key, so cli_llm.py wraps the claude CLI as a CrewAI BaseLLM: same model ids, same prompts, supports_function_calling() returning False, tokens fed to _track_token_usage_internal() so crew.usage_metrics reports them as it would for the API. Three corrections keep the numbers honest: the CLI's fixed preamble (366–370 tokens, measured before each batch and constant across probes) is subtracted from every call; extended thinking is off; and completion tokens for the one over-running call per run are scaled to the share of text CrewAI kept, so the bill is what the API charges with the stop sequence in place. Raw counts and every raw response are in calls.csv and calls/. With LLM(model="anthropic/claude-haiku-4-5-20251001") and an API key you get native tool calling instead of the text protocol, which removes the over-run entirely; the prompt then carries the tool schema and Anthropic's tool-use system prompt, 496 tokens for Haiku 4.5 by its pricing page, instead of CrewAI's text instructions.

Run it on your beat

Look up the industry: GET /v1/suggest/industries?prefix=<word> and put the id in INDUSTRY_ID.
Leave NEWS_MODE=summary and MAX_ARTICLES=40; that is the $0.030 configuration.
Run python brief_crew.py once and read the last line. The prompt-token count follows the tool's output (6,626 tokens on 8,819 characters of headlines here, 53,378 on 222,931 characters of bodies); if it is far above what your mode should give, look at what the tool returned before you tune an agent.

Three agents, one tool, one API call, and a bill of three cents: that is the whole CrewAI news agent, and every number above is in the CSVs next to this post.

FAQ

How do I create a custom tool in CrewAI?

A custom tool in CrewAI is a Python function decorated with @tool("name") from crewai.tools; its docstring becomes the description the agent reads and its signature becomes the input schema. The industry_news tool above takes no arguments and returns a string of 8,819 to 222,931 characters, which CrewAI passes to the model as the observation.

Can CrewAI fetch real-time news?

CrewAI can fetch real-time news through a custom tool that calls a news API; the agent itself has no network access. The tool in this post calls APITube's /v1/news/everything with industry.id=819 and published_at.start set 24 hours back, which returned 311 English Pharma articles for one day, and hands the model the 40 newest with at most two per site.

How much does a CrewAI agent cost to run?

A three-agent CrewAI news crew costs $0.030 per brief on Claude Haiku 4.5 when the tool returns key sentences, $0.018 on headlines and $0.067 on full bodies, measured as crew.usage_metrics times Anthropic's list price over 3 runs each; on Claude Sonnet 4.6 the key-sentence brief costs $0.096. The researcher accounts for 63–94% of the tokens because it is the only agent that reads the articles.

What is the difference between CrewAI and LangChain agents?

CrewAI describes work as agents with roles and tasks with context= dependencies and runs them sequentially or hierarchically, while a LangChain agent is one model in a tool-calling loop and LangGraph makes that loop an explicit graph. For a fixed pipeline like research → write → edit, the CrewAI version is the three Task objects above, and crew.usage_metrics gives the token bill without extra code.

How do I pass tool output between agents in CrewAI?

Tool output moves between CrewAI agents through task context, not through the tool: a task lists earlier tasks in context=[...] and receives their outputs as input. Here the researcher's shortlist of 8 stories with URLs reaches the writer through context=[research]; the writer never calls the tool and never sees the 40 articles, which is why its prompt is 918–1,218 tokens in every mode.

Resources

Files next to this post: brief_crew.py (the crew), cli_llm.py (measurement backend), measure.py, stats.py, plot.py, data.csv (one row per run), calls.csv (one row per LLM call), articles.json (the 311 articles), briefs/ (research notes, draft and final for all 12 runs), calls/ (raw model responses), batch-1/ (the earlier nine runs).
CrewAI: custom tools, LLMs and BaseLLM, Crews and usage_metrics
Anthropic model pricing, the $1/$5 and $3/$15 figures used above
APITube endpoints and response structure, where summary[] and industries[] are defined
The posts this one is measured against: Snyk's CrewAI security news crew, srk.ai's news agent, the LangChain real-time news agent on Dev.to

Disclosure: APITube is our product and the news API used here; the free tier at apitube.io covers a daily brief. The model prices and the CrewAI behaviour are the same whatever feed you plug into the tool.

One news bot for Bluesky and X, and why X gets only five posts a day

APITube News API — Sun, 27 Sep 2026 05:54:28 +0000

Takeaways

X: $0.015 per post, $0.200 per post with a URL, no free tier. Bluesky: $0.
One day of one industry: 270 articles → 252 unique headlines → 35 with a share image → 5 from sources ranked 6 or higher.
is_duplicate=0 and href dedupe removed 0 of the 270; normalising titles removed 18.
Of 29 share images fetched, 5 were over Bluesky's 1,000,000-byte blob limit and 6 were smaller than 1200×630 despite the filter.
Posting all 34 stories a day to X costs $204 a month; posting the top 5 costs $30.

What the bot does

Every 30 minutes a GitHub Actions job runs bot.py, and each run does five things:

Asks the news API for the last 24 hours of one industry, share-image articles only.
Drops anything whose normalised title or URL is already in posted.json.
Posts up to three new stories to Bluesky, each with a link card and a thumbnail under 1,000,000 bytes.
Sends the ones whose source ranks 6 or higher to X as well.
Writes what it posted back to posted.json, which the workflow commits so the next run remembers.

Step 1. Pick a feed and measure it before you post it

Filter stage (Sep 16, `industry.id=367`, `language.code=en`)	Articles
Raw	270
Unique by `href`	270
Unique by normalised title	252
`has_social_share_image=1`	35
+ unique title	34
+ `source.rankings.opr >= 5`	23
+ `source.rankings.opr >= 6`	5

One day, 16 September 2026 UTC, industry.id=367, English only; each stage is a filter the bot applies, counted from the same 270-row pull (data.csv).

Arrivals are lumpy. Over the raw 270 the busiest 30-minute slot had 21 articles and the median slot 4, which is why the script caps posts per run rather than posting whatever arrived.

Step 2. The script, part one: fetch, dedupe, thumbnails

The whole bot is one file. This first half talks to the news API and prepares the image; no social network is involved yet.

"""Post fresh industry news to Bluesky and X. Runs once, exits. Cron does the looping."""
import datetime as dt
import io
import json
import os
import re
import sys

import requests
from PIL import Image

API = "https://api.apitube.io/v1/news/everything"
STATE_FILE = "posted.json"
INDUSTRY_ID = os.environ.get("INDUSTRY_ID", "367")        # 367 = Renewable Energy
MAX_PER_RUN = int(os.environ.get("MAX_PER_RUN", "3"))
X_MIN_OPR = int(os.environ.get("X_MIN_OPR", "6"))          # X costs money per post; only the best go there
DRY_RUN = os.environ.get("DRY_RUN") == "1"


def fetch_recent(hours=24):
    since = dt.datetime.now(dt.timezone.utc) - dt.timedelta(hours=hours)
    r = requests.get(API, headers={"X-API-Key": os.environ["APITUBE_API_KEY"]}, timeout=30, params={
        "industry.id": INDUSTRY_ID, "language.code": "en",
        "published_at.start": since.strftime("%Y-%m-%dT%H:%M:%SZ"),
        "has_social_share_image": 1, "is_duplicate": 0,
        "sort.by": "published_at", "sort.order": "desc", "per_page": 50,
        "fl": "id,href,title,published_at,image,media,source.domain,source.rankings.opr",
    })
    r.raise_for_status()
    return r.json()["results"][::-1]                      # oldest first, so posts come out in order


def title_key(title):
    return " ".join(re.sub(r"[^a-z0-9 ]", "", title.lower()).split())


def image_url(article):
    if article.get("image"):
        return article["image"]
    return next((m["url"] for m in article.get("media") or [] if m.get("type") == "image"), None)


def fetch_thumb(url, cap=1_000_000):
    """Bluesky rejects blobs over 1,000,000 bytes; shrink anything bigger."""
    data = requests.get(url, timeout=20, headers={"User-Agent": "industry-news-bot/0.1"}).content
    if len(data) <= cap:
        return data
    im = Image.open(io.BytesIO(data)).convert("RGB")
    im.thumbnail((1200, 1200))
    buf = io.BytesIO()
    im.save(buf, "JPEG", quality=85)
    return buf.getvalue()

Step 3. The script, part two: Bluesky and X

def bluesky_client():
    from atproto import Client
    client = Client()
    client.login(os.environ["BSKY_HANDLE"], os.environ["BSKY_APP_PASSWORD"])
    return client


def post_bluesky(client, article, thumb):
    from atproto import client_utils, models
    text = client_utils.TextBuilder().text(article["title"] + "\n").link(article["source"]["domain"], article["href"])
    blob = client.upload_blob(thumb).blob if thumb else None
    card = models.AppBskyEmbedExternal.External(uri=article["href"], title=article["title"], description="", thumb=blob)
    client.send_post(text, embed=models.AppBskyEmbedExternal.Main(external=card), langs=["en"])


def x_client():
    import tweepy
    return tweepy.Client(
        consumer_key=os.environ["X_API_KEY"], consumer_secret=os.environ["X_API_SECRET"],
        access_token=os.environ["X_ACCESS_TOKEN"], access_token_secret=os.environ["X_ACCESS_SECRET"],
    )


def post_x(client, article):
    client.create_tweet(text=f'{article["title"]} {article["href"]}')  # a URL counts as 23 chars on X

Step 4. The main loop, and what a dry run prints

def main():
    state = json.load(open(STATE_FILE)) if os.path.exists(STATE_FILE) else {"titles": [], "hrefs": []}
    seen_titles, seen_hrefs = set(state["titles"]), set(state["hrefs"])

    fresh = [a for a in fetch_recent() if title_key(a["title"]) not in seen_titles and a["href"] not in seen_hrefs]
    batch, keys = [], set()
    for a in fresh:                                      # same story from two domains -> post once
        k = title_key(a["title"])
        if k not in keys:
            keys.add(k)
            batch.append(a)
    batch = batch[:MAX_PER_RUN]
    print(f"fetched {len(fresh)} unseen, posting {len(batch)}")

    bsky = None if DRY_RUN else bluesky_client()
    x = None if DRY_RUN else x_client()
    for a in batch:
        opr = (a.get("source", {}).get("rankings") or {}).get("opr") or 0
        url = image_url(a)
        thumb = fetch_thumb(url) if url else None
        to_x = opr >= X_MIN_OPR
        print(f"[{'dry' if DRY_RUN else 'post'}] bsky{' + x' if to_x else ''} | opr {opr} | thumb {len(thumb) if thumb else 0} B | {a['title'][:70]}")
        if not DRY_RUN:
            post_bluesky(bsky, a, thumb)
            if to_x:
                post_x(x, a)
        state["titles"].append(title_key(a["title"]))
        state["hrefs"].append(a["href"])

    state["titles"], state["hrefs"] = state["titles"][-2000:], state["hrefs"][-2000:]
    json.dump(state, open(STATE_FILE, "w"), indent=0)


if __name__ == "__main__":
    sys.exit(main())

Three consecutive runs with DRY_RUN=1, about 04:59 UTC:

fetched 33 unseen, posting 3
[dry] bsky | opr 4 | thumb 601276 B | Chongqing, Spain's Extremadura Deepen Ties in EVs and Green Energy
[dry] bsky | opr 3 | thumb 55318 B | Egypt's Wind Turbine Manufacturing Push: A New Blueprint for Africa's
[dry] bsky | opr 4 | thumb 152741 B | Heathrow expansion incompatible with climate targets, advises UK gover
fetched 30 unseen, posting 3
...
fetched 27 unseen, posting 3
[dry] bsky | opr 5 | thumb 956337 B | Elcogen and Shanghai HyEnergy advance collaboration on commercial depl

Step 5. Every 30 minutes on GitHub Actions

name: industry-news-bot
on:
  schedule:
    - cron: "*/30 * * * *"
  workflow_dispatch:
permissions:
  contents: write
jobs:
  post:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install requests pillow atproto tweepy
      - run: python bot.py
        env:
          APITUBE_API_KEY: ${{ secrets.APITUBE_API_KEY }}
          BSKY_HANDLE: ${{ secrets.BSKY_HANDLE }}
          BSKY_APP_PASSWORD: ${{ secrets.BSKY_APP_PASSWORD }}
          X_API_KEY: ${{ secrets.X_API_KEY }}
          X_API_SECRET: ${{ secrets.X_API_SECRET }}
          X_ACCESS_TOKEN: ${{ secrets.X_ACCESS_TOKEN }}
          X_ACCESS_SECRET: ${{ secrets.X_ACCESS_SECRET }}
      - run: |
          git config user.name "news-bot"
          git config user.email "news-bot@users.noreply.github.com"
          git add posted.json
          git commit -m "state: $(date -u +%FT%TZ)" || exit 0
          git push

What X costs at this volume

The X pricing page lists "Post: Create" at $0.015 per request and "with URLs" at $0.200 per request, pay-per-use, no subscription and no free tier. A news bot posts URLs. Multiply by the feed:

Sent to X per day	Per day	Per month (30 days)	Bluesky
All 34	$6.80	$204	$0
Sources with `opr >= 5` (23)	$4.60	$138	$0
Sources with `opr >= 6` (5)	$1.00	$30	$0
All 34, no URL in the post	$0.51	$15.30	$0

Daily counts from the Sep 16 funnel × $0.200 per URL post × 30 days; Bluesky posting is free, so its bar is zero in every row.

Where this leaves you

FAQ

Is the X (Twitter) API free for bots?

How much does it cost to post a link with the X API?

Can you make a news bot on Bluesky?

How do I schedule a Python bot for free?

Is Tweepy still working in 2026?

Resources

X API pricing: https://docs.x.com/x-api/getting-started/pricing
atproto Python SDK: https://atproto.blue
Tweepy documentation: https://docs.tweepy.org
APITube /v1/news/everything reference (industry, image and duplicate filters): https://docs.apitube.io/platform/news-api/everything
GitHub Actions scheduled events: https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#schedule
Scripts and CSVs behind every number here: bot.py, bot.yml, pull_day.py, data.csv (the 270 articles), funnel.csv, images.csv, slots.csv

APITube is the news API used above — free tier at apitube.io.

Recall alerts for the stuff you own, by text message

APITube News API — Thu, 24 Sep 2026 06:12:37 +0000

Over 31 days, a list of 26 brands from one home produced 38 text messages, 21 of them about a distinct product recall, for about $2 in Twilio fees. That is the whole result. The rest of this post is the 80-line script that did it and what the log looked like.

The recall tracker is a Python script that runs once a day, asks a news API for headlines with the word "recall" and any name from a text file, and sends each new headline to your phone through Twilio. No app, no account with a recall service, no six agency mailing lists. If you can run a Python file from a terminal, you can run this.

One honest note before the numbers. We wrote the script this month. Instead of waiting a month to publish, we replayed the same daily query over August 17 to September 16, 2026 with a --dry-run flag that prints texts instead of sending them. Every number below comes from that replay, and the CSV it wrote is next to this post.

Takeaways

26 names on the list, 47 API hits in 31 days, 38 texts after dedup and a name check.
21 distinct recalls, 10 repeat headlines about a recall already texted, 6 stories about a recall, 1 wrong match.
17 of the 26 names never came up. Walmart alone was 17 of 38 texts.
66 SMS segments cost $0.55 at Twilio plus carrier fees, plus $1.15 for the number.
A per-brand cooldown does not help: one day of cooldown removes 13 texts and 3 real recalls.

Why not just subscribe to recalls.gov

Because the official lists send everything. Recalls.gov forwards notices from six US agencies with no way to say "only Toyota and Whirlpool". The U.S. Consumer Product Safety Commission (CPSC) email covers CPSC products only, so a car recall from the National Highway Traffic Safety Administration (NHTSA) or a frozen berry recall from the Food and Drug Administration (FDA) never arrives. Consumer Reports has a car recall tracker that texts you, but it is vehicles by VIN and nothing else.

Source	Covers	Filter by brand	Texts you	API
cpsc.gov email / RSS	CPSC products only	No	No	Yes
recalls.gov email	Six agencies	No	No	No
Consumer Reports car tracker	NHTSA vehicles	By VIN	Yes	No
News API + this script	Anything a newsroom reported	Yes, your list	Yes, via Twilio	Yes

Unlike the recalls.gov email, which sends every recall from six agencies, the script sends only headlines that name something on your list, which means 38 texts a month for 26 names instead of hundreds.

Step 1. Write down what you own

One name per line in my_stuff.txt. We used a plausible home: appliances, two cars, kid gear, the stores we shop at, a few food brands.

Samsung
LG
Whirlpool
Bosch
KitchenAid
Instant Pot
Dyson
Philips
Toyota
Honda
Ford
Subaru
Fisher-Price
Graco
IKEA
Peloton
Walmart
Costco
Trader Joe's
Kroger
Target
Great Value
Kirkland
Nestle
Tyson
Blue Buffalo

Store names matter more than you would guess. Food recalls are usually reported as "sold at Walmart, Target and Kroger", not by the packer's name.

Step 2. Find the filter that actually works

We used APITube, our News API Intelligence (disclosure at the bottom). Articles come back already tagged with entities, categories and events, which is why the obvious filters were the first thing we tried. They did not do what we hoped, so here is what each one returned, measured on the same day:

Filter	What happened
`event.type=recall`	Accepted silently, returns the unfiltered feed. First hit was a story about tariffs.
`event.name=recall`	`400 ER0228`: "entity event name 'recall' not found".
`category.id=medtop:20000207` (IPTC "product recall")	18 of the latest 197 English articles had "recall" in the headline.
`query=recall AND (Walmart OR Ford OR …)`	47 hits in 31 days, 45 of them with a listed name in the headline.

So the working route is the boolean query parameter: a bare word searches headlines, and AND/OR combine them. One request covers the whole list.

curl -G "https://api.apitube.io/v1/news/everything" \
  -H "X-API-Key: YOUR_API_KEY" \
  --data-urlencode 'query=recall AND (Walmart OR Ford OR Toyota OR "Great Value")' \
  --data-urlencode "language.code=en" \
  --data-urlencode "published_at.start=2026-09-16" \
  --data-urlencode "sort.by=published_at" \
  --data-urlencode "sort.order=asc" \
  --data-urlencode "per_page=200"

Each result is a large object. The script uses five fields of it:

{
  "id": 3083205852,
  "title": "Fuel Tank Issue Sparks Ford F-150 Recall",
  "href": "https://lite987.com/ixp/39/p/ford-recall-new-york-state-drivers/",
  "published_at": "2026-09-16T13:21:38.000Z",
  "source": { "domain": "lite987.com" }
}

Names with a space, apostrophe or hyphen go in quotes ("Great Value", "Trader Joe's", "Fisher-Price"). The script does that for you.

Step 3. The script

Save this as recall_alerts.py next to my_stuff.txt. It needs requests and twilio (pip install requests twilio).

import csv, os, re, sys, pathlib, datetime as dt
import requests

API = "https://api.apitube.io/v1/news/everything"
HERE = pathlib.Path(__file__).parent
NAMES = [n.strip() for n in (HERE / "my_stuff.txt").read_text().splitlines() if n.strip()]
LOG = HERE / "alerts.csv"
DRY = "--dry-run" in sys.argv


def arg(flag, default=None):
    return sys.argv[sys.argv.index(flag) + 1] if flag in sys.argv else default


def term(name):
    return f'"{name}"' if re.search(r"[\s'\-]", name) else name


QUERY = "recall AND (" + " OR ".join(term(n) for n in NAMES) + ")"


def fetch(start, end=None):
    params = {
        "query": QUERY,
        "language.code": "en",
        "published_at.start": start,
        "sort.by": "published_at",
        "sort.order": "asc",
        "per_page": 200,
        "page": 1,
    }
    if end:
        params["published_at.end"] = end
    while True:
        r = requests.get(API, headers={"X-API-Key": os.environ["APITUBE_API_KEY"]}, params=params, timeout=60)
        r.raise_for_status()
        data = r.json()
        yield from data["results"]
        if not data.get("has_next_pages"):
            return
        params["page"] += 1


def title_key(title):
    return re.sub(r"[^a-z0-9]+", " ", title.lower()).strip()


def names_in(title):
    return [n for n in NAMES if re.search(r"(?<![A-Za-z])" + re.escape(n) + r"(?![A-Za-z])", title)]


def send_sms(text):
    if DRY:
        print(text, "\n")
        return "dry-run"
    from twilio.rest import Client
    client = Client(os.environ["TWILIO_ACCOUNT_SID"], os.environ["TWILIO_AUTH_TOKEN"])
    msg = client.messages.create(body=text, from_=os.environ["TWILIO_FROM"], to=os.environ["MY_PHONE"])
    return msg.sid


rows = list(csv.DictReader(LOG.open())) if LOG.exists() else []
seen = {row["title_key"] for row in rows}
since = arg("--since") or (rows[-1]["published_at"] if rows else (dt.datetime.utcnow() - dt.timedelta(days=1)).strftime("%Y-%m-%dT%H:%M:%SZ"))
until = arg("--until")

with LOG.open("a", newline="") as f:
    w = csv.writer(f)
    if not rows:
        w.writerow(["published_at", "article_id", "names", "title_key", "title", "url", "source", "sms_chars", "sid"])
    for a in fetch(since, until):
        key = title_key(a["title"])
        names = names_in(a["title"])
        if key in seen or not names:
            continue
        text = f"RECALL ({', '.join(names)}): {a['title']} {a['href']}"
        sid = send_sms(text)
        w.writerow([a["published_at"], a["id"], "|".join(names), key, a["title"], a["href"], a["source"]["domain"], len(text), sid])
        seen.add(key)

What each part does, in plain words:

QUERY builds the recall AND (…) string from your file.
fetch() asks the API for everything since the last run, 200 at a time, and follows has_next_pages.
title_key() turns a headline into lowercase letters and digits. Syndicated copies (the same F-150 headline ran on three radio station sites) collapse into one key, so you get one text, not three.
names_in() checks the headline again for your names, case-sensitive and whole-word. The API matches loosely; this second check decides which names go into the text.
send_sms() prints in --dry-run mode and calls Twilio otherwise. Four environment variables: TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_FROM (your Twilio number) and MY_PHONE. A trial account can only text numbers you verified in the console, and it prefixes every message with a trial notice.
alerts.csv is both the log and the memory. The last published_at in it is where the next run starts.

Step 4. Run it, then let cron run it

First run, dry, from a date you pick:

export APITUBE_API_KEY=...   # free tier at apitube.io
python3 recall_alerts.py --dry-run --since 2026-09-10

Once the printed texts look right, add the Twilio variables and a cron line. Once a day at 08:00 is enough. Recalls are not breaking news; the article is usually hours behind the official notice anyway.

0 8 * * * cd ~/recall-alerts && python3 recall_alerts.py

What 31 days looked like

The replay ran --since 2026-08-17 --until 2026-09-16T23:59:59Z. 47 API hits became 40 unique headlines, and 38 texts after the name check. We then read all 38 and labelled them by hand.

Label	Texts	What it means
Distinct recall	21	First headline about a recall you had not been told about
Repeat coverage	10	Another outlet, another headline, same recall
About a recall	6	A stock story, a sales story, a lawyer ad, a listicle, commentary, a Honda "check your recall status" notice
Wrong	1	Doug Ford, the Ontario premier, being asked to recall the legislature

Name	Texts
Walmart	17
Ford	11
Toyota	6
Target	5
Kroger	3
Costco	2
Great Value	2
Honda	1
Subaru	1

(A text can carry more than one name, so the column adds up past 38.) The other 17 names, from Samsung to Blue Buffalo, produced nothing in 31 days. The Walmart frozen-berry E. coli recall alone produced 8 texts over two weeks as it expanded state by state. The busiest day was September 4 with 5 texts; 24 of the 31 days had at least one.

The name check dropped 2 of the 47 hits. One drop was right: a Tesla door-handle recall matched because the headline contained the verb "target". One was a loss: a Goal Zero power-station recall posted on a Costco fan site, where "Costco" appeared only in the body. Title-only matching has a price, and that was it for the month.

What it costs

A recall tracker for 26 names costs about $2 a month: 66 SMS segments in 31 days at Twilio's US long-code rate of $0.0083 per segment ($0.55), carrier pass-through fees of $0.0035–0.005 per segment ($0.23–0.33), and $1.15 a month for the number. $1.93 to $2.03 for the month. 28 texts needed two segments because the article URL pushes them past 160 characters; 10 fit in one.

One detail that matters for the bill: the text starts with RECALL (Walmart): and not Recall — Walmart. An em dash is not in the GSM-7 character set, and a single one switches the whole message to 70-character segments.

Should you add a cooldown?

The obvious fix for 8 berry texts is "don't text about the same name twice in N days". We replayed the log with that rule:

Cooldown per name	Texts	Distinct recalls caught
None	38	21 of 21
1 day	25	18 of 21
3 days	20	15 of 21
7 days	14	10 of 21

A one-day cooldown removes 13 texts, and 3 of those were distinct recalls: a Ford Bronco airbag recall, a Toyota GR Supra recall in China and a UK roundup naming Ford and Toyota. Ford had five separate recalls in the month, and they land days apart. A per-name cooldown is the wrong lever for recall alerts, because it throws away real recalls faster than it removes repeats. Our recommendation: no cooldown. If 38 texts is too many, shorten the list. Taking Walmart off it leaves 28 texts; taking Walmart and Ford off leaves 18.

FAQ

How do I get notified about product recalls?

The two ways to get notified about product recalls are the recalls.gov email, which sends every notice from six US agencies, and a script like the one above, which texts you only when a headline names something you own. The official email is complete but unfiltered; the script is filtered but only as good as the newsroom coverage.

Is there a product recall API?

There is no single product recall API for all products. The CPSC Recall API covers consumer products under its jurisdiction, not vehicles, food or drugs. For everything else, a news API with a headline search covers whatever gets reported: query=recall AND (Brand OR Brand) returned 47 headlines in 31 days for 26 names.

Is there an app for product recalls?

We did not find an app that watches product recalls for a personal list of brands across all agencies. Consumer Reports covers vehicles and several retailers cover their own sales. This script is the app: a text file, a cron line and about $2 a month.

Does Amazon notify you of recalls?

Amazon notifies you of recalls only for items bought on Amazon, by email and a notice in Your Orders. It does not know about the Instant Pot you bought elsewhere, which is what the list in my_stuff.txt is for.

Limits

Title-only matching misses recalls whose headline names the product and not the brand or store. The Goal Zero power-station recall was the one we lost this month: "Costco" was in the body, not the headline.
Title dedup merges identical headlines, not different headlines about one recall. Expect a few texts per big recall.
The news is hours behind the official notice. The text links to the article; check the lot number and dates there or on the agency site before you throw anything out.
17 of 26 names were silent for a month. That is a normal month, not a broken script.

The script, my_stuff.txt and the 38-row data.csv from the replay are next to this post. Change the list and run it.

Resources

recalls.gov — the six-agency hub and its email subscription
CPSC Recall API — official API for CPSC-jurisdiction recalls
Twilio Messaging quickstart for Python — client setup and trial-account rules
APITube docs: /v1/news/everything — the query parameter and its 31-day window

Disclosure: APITube is our product, a News API Intelligence, and the API used above. It has a free tier at apitube.io.

A news site in Flask, deployed for free

APITube News API — Mon, 21 Sep 2026 16:33:27 +0000

A news site in Flask, deployed for free

The copy-paste Flask news app calls the news API inside the request handler. On our laptop that made the business page take 10.6 seconds to load, and every visitor cost one API call: 30 page views, 30 calls. With a five-minute cache and one background thread the same 30 views cost 1 call, and the page rendered in under a millisecond. This post builds that version and deploys it on a free tier.

A Flask news app is a small Python web server that fetches headlines from a news API, keeps them in memory for a few minutes, and renders them with a Jinja template. The one below is 110 lines, has category pages, search and translated world news, and runs on a free key and a free host.

Takeaways

Top headlines page: 310 ms cold, API median 285 ms over 30 calls.
Category pages through category.id: 1.8 s (health) to 10.6 s (business). Not something a visitor should wait for.
30 views without a cache = 30 API calls; with a 300 s cache = 1 call, median <1 ms per view.
Free plan: 10 requests/min, 10 articles/page, results 12 hours behind. The cache keeps a site inside that.
Render free tier: 750 hours/month, sleeps after 15 min idle, wakes in about 1 minute.

This is for Python beginners who have run flask run once and want a project that survives being deployed. Everything below was measured on 16 September 2026 with a Basic-plan key, in-process with Flask's test client, on a laptop. The CSV is next to the charts.

What we're building
The recipe everyone copies, and where it breaks
The code, in four parts
What the pages cost, measured
What the cache saves
Deploy it for free
Lock the key
FAQ

What we're building

A news site with six pages and a search box:

/ top headlines for one country
/c/business, /c/tech, /c/sport, /c/health, /c/politics category pages
/world German, French and Spanish headlines shown with their English translation
/search?q=... headline search

Files: app.py (110 lines), templates/index.html (38 lines), requirements.txt, render.yaml. No database, no JavaScript, no CSS framework.

The recipe everyone copies, and where it breaks

Search "flask news app" and the top tutorials share one shape: one route, requests.get(...) inside it, the API key pasted into the source, run it on localhost:5000, done. Three things go wrong the moment it leaves the laptop.

The key is in the code. One of the top-ranking tutorials prints its key in the finished example. Anyone who forks the repo gets your quota.
The API call is inside the handler. Every visitor waits for the API, and every visitor spends one request. On a free plan with 10 requests per minute, the eleventh visitor in a minute gets an error page.
The free tier of the API those tutorials use is localhost-only. NewsAPI's developer plan returns HTTP 426 from any deployed host, so "deploy" is a step those posts skip.

We keep the key in an environment variable, move the API call behind a cache, and pick an API whose free tier works from a server. Disclosure: we work on APITube, which is the API used below. Its free tier has real limits, listed near the end, and the caching pattern works with any news API.

Step 1: the project

flask-news/
├── app.py
├── templates/index.html
├── requirements.txt
└── render.yaml

# requirements.txt
flask==3.1.*
requests==2.32.*
gunicorn==23.*

python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
export APITUBE_API_KEY=your_key_here

Step 2: app.py, in four parts

The fetch function and the cache

import os
import threading
import time

import requests
from flask import Flask, abort, render_template, request

API = "https://api.apitube.io/v1/news"
KEY = os.environ["APITUBE_API_KEY"]
COUNTRY = os.environ.get("NEWS_COUNTRY", "us")
CACHE_TTL = int(os.environ.get("CACHE_TTL", "300"))  # seconds
FIELDS = "id,title,href,description,image,published_at,language,source.domain,translations.en.title"

CATEGORIES = {
    "business": "medtop:04000000",
    "tech": "medtop:13000000",
    "sport": "medtop:15000000",
    "health": "medtop:07000000",
    "politics": "medtop:11000000",
}

app = Flask(__name__)
_cache = {}


def fetch(path, _force=False, **params):
    key = (path, tuple(sorted(params.items())))
    hit = _cache.get(key)
    if hit and not _force and time.time() - hit[0] < CACHE_TTL:
        return hit[1]
    r = requests.get(
        f"{API}/{path}",
        params={**params, "fl": FIELDS, "per_page": 20},
        headers={"X-API-Key": KEY},
        timeout=30,
    )
    r.raise_for_status()
    articles = r.json()["results"]
    _cache[key] = (time.time(), articles)
    return articles

fetch() is the only place that talks to the API. The cache is a dict keyed by endpoint plus sorted parameters, holding a timestamp and the article list. fl= asks for nine fields instead of the full sixty-field article, which keeps the response small. The category IDs are IPTC media topics; the full list is in the category reference.

One function that says what backs each page

def page_query(slug):
    """One place that says which API call backs which page."""
    if slug == "top":
        return "top-headlines", {"language.code": "en", "source.country.code": COUNTRY}
    if slug == "world":
        return "top-headlines", {"language.code": "de,fr,es"}
    # Category filters are slow on the archive: pin them to the last day and to ranked sources.
    return "everything", {
        "category.id": CATEGORIES[slug],
        "published_at.start": "NOW-1DAY",
        "source.rank.opr.min": 5,
        "language.code": "en",
        "source.country.code": COUNTRY,
    }

Why category pages use /everything with a one-day window instead of /top-headlines is a measurement, covered below.

The routes

@app.route("/")
def home():
    path, params = page_query("top")
    return render_template("index.html", articles=fetch(path, **params), title="Top headlines")


@app.route("/c/<slug>")
def category(slug):
    if slug not in CATEGORIES:
        abort(404)
    path, params = page_query(slug)
    return render_template("index.html", articles=fetch(path, **params), title=slug.title())


@app.route("/world")
def world():
    path, params = page_query("world")
    return render_template("index.html", articles=fetch(path, **params), title="World, translated")


@app.route("/search")
def search():
    q = request.args.get("q", "").strip()
    articles = fetch("everything", title=q, **{"language.code": "en", "sort.by": "published_at"}) if q else []
    return render_template("index.html", articles=articles, title=f"Search: {q}" if q else "Search")

The error page and the warm thread

@app.errorhandler(requests.RequestException)
def api_down(err):
    status = getattr(err.response, "status_code", None)
    msg = "Too many requests, try again in a minute." if status == 429 else "The news feed is unavailable right now."
    return render_template("index.html", articles=[], title=msg), 503


def warm_cache():
    """Refresh every page in the background so no visitor ever waits for the API."""
    while True:
        for slug in ["top", "world", *CATEGORIES]:
            path, params = page_query(slug)
            try:
                fetch(path, _force=True, **params)
            except requests.RequestException:
                pass  # keep the stale copy, try again next round
            time.sleep(2)  # spread calls out under the per-minute limit
        time.sleep(CACHE_TTL)


if os.environ.get("WARM_CACHE", "1") == "1":
    threading.Thread(target=warm_cache, daemon=True).start()

if __name__ == "__main__":
    app.run(debug=True)

The error handler catches every requests failure, including a 429 from the API, and renders the normal template with a message and a 503 status. We forced a 429 in the test run and got the page, not a stack trace. The warm thread fetches all seven pages once, sleeps CACHE_TTL, and repeats. Visitors only ever read the dict.

Step 3: the template

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{{ title }}</title>
  <style>
    body { font: 16px/1.5 system-ui, sans-serif; max-width: 720px; margin: 2rem auto; padding: 0 1rem; color: #111; }
    nav a { margin-right: .8rem; color: #0254EC; text-decoration: none; }
    form { margin: 1rem 0; }
    article { display: flex; gap: 1rem; padding: 1rem 0; border-top: 1px solid #ddd; }
    article img { width: 120px; height: 80px; object-fit: cover; border-radius: 4px; flex: none; }
    small { color: #666; }
    .orig { color: #666; font-style: italic; }
  </style>
</head>
<body>
  <nav>
    <a href="/">Top</a>
    {% for slug in ["business", "tech", "sport", "health", "politics"] %}<a href="/c/{{ slug }}">{{ slug|title }}</a>{% endfor %}
    <a href="/world">World</a>
  </nav>
  <form action="/search"><input name="q" placeholder="Search headlines" value="{{ request.args.get('q', '') }}"> <button>Go</button></form>
  <h1>{{ title }}</h1>
  {% for a in articles %}
  <article>
    {% if a.image %}<img src="{{ a.image }}" alt="">{% endif %}
    <div>
      <a href="{{ a.href }}">{{ a.translations.en.title or a.title }}</a>
      {% if a.translations.en.title %}<div class="orig">{{ a.title }}</div>{% endif %}
      <br><small>{{ a.source.domain }} · {{ a.published_at[:16].replace("T", " ") }} · {{ a.language }}</small>
    </div>
  </article>
  {% else %}
  <p>Nothing here yet.</p>
  {% endfor %}
</body>
</html>

The one line worth noticing is a.translations.en.title or a.title. Every non-English article comes with an English title and description already attached; English articles have null there, so the or falls back to the original. On the /world page all 20 of 20 articles had a translation. No translation service, no extra call.

Step 4: run it

flask run

Open http://127.0.0.1:5000. The warm thread starts with the app, so by the time you click Business the page is already in memory. Set CACHE_TTL=0 if you want to see the uncached timings yourself.

What the pages cost, measured

Two cold runs per page, cache off, one API call each. Time is the full Flask request through the test client, so it includes the API round trip and rendering.

Page	Run 1	Run 2	Articles
`/` top headlines	310 ms	513 ms	20
`/c/business`	10,622 ms	10,250 ms	20
`/c/tech`	2,909 ms	2,506 ms	20
`/c/sport`	10,155 ms	10,259 ms	19
`/c/health`	1,775 ms	1,797 ms	20
`/c/politics`	4,643 ms	4,734 ms	20
`/world`	389 ms	575 ms	20
`/search?q=climate`	681 ms	591 ms	20

The plain endpoints are fast. Category filters are not: a category.id query walks a much larger slice of the index, and business and sport are the biggest categories. Our first version used /top-headlines with category.id and no date bound, and four of the five categories came back as a 502 after 30 seconds or a 500; tech alone answered, in 24.7 s. Unlike /top-headlines with a bare category.id, which failed on four of five categories, /everything with published_at.start=NOW-1DAY and source.rank.opr.min=5 answered every category under 11 s and gave the same timings on both runs, which means the date bound, not the endpoint, is what makes a category page usable. Ten seconds is still not a page load, which is the whole argument for the warm thread: the visitor reads a copy that was fetched in the background, and the 10 s happens where nobody is waiting.

What the cache saves

Thirty requests to /, twice: once with CACHE_TTL=0, once with CACHE_TTL=300.

Setting	Page views	API calls	Median per view	Slowest view
Cache off	30	30	285 ms	461 ms
Cache 300 s	30	1	<1 ms	263 ms

The math for a real day: without a cache, calls equal page views. Unlike the copy-paste recipe, where every visitor is one API call, the cached app spends at most 12 calls an hour, 288 a day per page whatever the traffic, which means visitors no longer decide the API bill. Seven warmed pages cost 2,016 calls a day. A Free key allows 10 calls a minute; the warm loop makes 7 calls per cycle with 2 s gaps, so it fits, with room for search queries on top.

When you need which piece:

Under 10 visitors a minute, no category pages: the plain recipe works on a Free key. Add the cache anyway; it is 8 lines.
Any category page: you need the cache and the warm thread, because 10 s is not a page load at any traffic level.
More than 10 uncached visitors a minute on Free, or 50 on Basic: without a cache you hit the limit and serve the 503 page.
More than one gunicorn worker: each worker has its own dict and its own warm thread, so calls multiply by worker count. Keep -w 1 on a small instance, or move the cache to Redis.

Deploy it for free

We picked Render because its free web service runs from a render.yaml in the repo, needs no card to start, and takes environment variables from the dashboard. The numbers in this post were measured locally; the deploy steps below follow Render's documentation. What the free tier gives you, from Render's own docs: 750 instance hours a month, the service spins down after 15 minutes without traffic, and waking it takes about one minute. That minute is the price; for a personal news page it is fine, for anything with an audience it is not.

# render.yaml
services:
  - type: web
    name: flask-news
    runtime: python
    plan: free
    buildCommand: pip install -r requirements.txt
    startCommand: gunicorn -w 1 -b 0.0.0.0:$PORT app:app
    envVars:
      - key: APITUBE_API_KEY
        sync: false
      - key: NEWS_COUNTRY
        value: us

Steps: push the four files to GitHub, in Render choose New → Blueprint, pick the repo, and when it asks for APITUBE_API_KEY paste the key (sync: false means it is never written to the file). Build takes a couple of minutes; the URL is https://flask-news.onrender.com or whatever name you chose. Every deploy restarts the process, which empties the cache, and the warm thread refills it in about 43 seconds, the sum of the seven cold fetches from run 1 (30.8 s) plus six 2 s gaps.

Two alternatives we checked. PythonAnywhere has a free tier without a card, but its free web apps only allow outbound requests to an allowlist of hosts, so check whether your API's host is on it before choosing it. Fly.io no longer has a free tier: every organization needs a card on file, and the smallest machine is $2.02 a month.

Lock the key

The key never appears in a file. Locally it lives in the shell, on Render in the dashboard. Two more things cost nothing:

In the APITube dashboard, restrict the key to your server's outbound IP, or to your site's domain via the referrer allowlist. A blocked request returns 403 ER0601 or ER0602 and does not count against quota.
/v1/balance is free to call and returns the points left on the key. A one-line cron that reads it and emails you under a threshold is the whole budget alarm.

What the Free plan gives you

The rate limits page is short and worth reading before you rely on it: 10 requests a minute, 10 articles a page (our per_page=20 is clamped to 10), 5 pages deep, and every result 12 hours behind publication. The delay applies everywhere, streams included. The Basic key we measured with has no delay, 50 requests a minute and 250 per page. So on Free the site works exactly as built, with yesterday's news and ten stories a page.

FAQ

How do you make a news app in Flask?
A Flask news app needs one route per page, one function that calls the news API, and a Jinja template that loops over the articles. The version above adds a dict cache with a time-to-live and a background thread that refreshes it, so visitors never wait on the API. The complete app is 110 lines.

How do you deploy a Flask app for free?
A Flask app deploys for free on Render with a render.yaml that sets runtime: python and startCommand: gunicorn -w 1 -b 0.0.0.0:$PORT app:app, connected as a Blueprint, with the API key set as an environment variable. Render's free tier gives 750 hours a month and sleeps after 15 idle minutes.

Which news API is free?
A free news API plan exists at most providers, with limits: NewsAPI's free plan works on localhost only, APITube's free plan works from a server but returns results 12 hours late, at 10 requests a minute and 10 articles a page. With responses cached for five minutes, those limits are workable for a small site.

How do you hide an API key in Flask?
An API key stays out of Flask code when it is read with os.environ["APITUBE_API_KEY"], exported in the shell locally, set in the host's dashboard in production, and never committed. Restricting the key by IP or domain on the API side makes a leaked key useless anywhere else.

Where this leaves you

A Flask news app that survives deployment is the recipe plus three things: the key in the environment, the API call behind a five-minute cache, and a thread that refills the cache so the 10-second category query happens off the request path. That turned 30 views into 1 API call and a 10.6 s page into a cached read, and it runs on a free key and a free host. The next step that changes the picture is a second gunicorn worker, at which point the dict becomes Redis.

APITube is one of the APIs mentioned here, and it is the one the code targets. Free tier at apitube.io; the free key is enough to run everything in this post.

Resources

Code and data for this post: app.py, templates/index.html, render.yaml, data.csv, plot.py in the images folder next to this article
Flask quickstart, gunicorn docs
Render free tier, Fly.io pricing, PythonAnywhere plans
APITube docs: top headlines, search, rate limits and plans, categories, Flask integration
NewsAPI pricing, for the localhost-only note

A news app without a backend, in one HTML file

APITube News API — Thu, 17 Sep 2026 17:40:22 +0000

A news app without a backend, in one HTML file

A news app without a backend is a single HTML file that calls a news API from the browser with fetch, renders the JSON, and is served by a static host such as GitHub Pages. No server of yours runs anywhere. Ours is 97 lines. The first headline lands 858 ms after page load, and a repeat visit in the same tab makes zero network requests because the response is cached in sessionStorage for 15 minutes.

The part that most "news app with vanilla JS" tutorials skip: the API key ships to the browser, where anyone can read it from the network tab. So this tutorial spends as much time on the key as on the DOM. There are three ways to handle it, and the right one depends on one number: how many requests per day you can afford. On a free plan that number is 100.

Everything here was measured on 16 September 2026 with curl and headless Chrome. The CSV files behind every number sit next to the article.

Disclosure: APITube is our product. We use it for the requests below because it answers browser calls from any origin; the file structure works with any JSON news API.

Takeaways

Asking for 7 fields instead of the full article object shrank a 10-headline response from 238 KB to 9.5 KB and cut the median request from 1.21 s to 0.85 s (15 runs each).
Sending the key as an X-API-Key header fails in Chrome today: the preflight reply carries Access-Control-Allow-Origin twice. The key in the query string works.
A 100-requests-per-day free plan is gone after 100 first visits if the browser calls the API directly.
A 35-line Cloudflare Worker with a 15-minute cache caps upstream calls at 96 per day, whatever the traffic. Cached responses came back in 3 ms locally, uncached in 656 ms.

Contents: Step 1: get a key you can afford to expose · Step 2: the request, and two things that break in the browser · Step 3: index.html · Step 4: deploy to GitHub Pages · Step 5: when the key must stay secret, a 35-line Worker · FAQ

Who this is for

This is for frontend beginners who know what fetch and querySelector do and want a deployable project, not a codepen. No build step, no npm, no framework. You need a GitHub account and an API key.

Step 1: get a key you can afford to expose

Key model	When it fits	What limits the damage
Test key (`api_test_…`)	Demos, portfolio, learning	Consumes no quota; article text comes back truncated; stricter rate limit
Live key with referrer and IP rules	Real headlines, traffic under 100 requests/day	Dashboard rules restrict the key to your domain and to one endpoint
Live key behind a Worker proxy	Real headlines, more than 100 requests/day	Key never leaves the Worker; the cache absorbs the traffic (Step 5)

The dashboard has a Test mode toggle at the bottom of the sidebar. Keys created there start with api_test_ and return the real response shape, so the file below works unchanged. For a live key, set the referrer rule to your GitHub Pages origin and the endpoint scope to /v1/news/everything before you commit anything. Referrer rules are not a lock: a browser sends the Referer header, curl sends whatever it likes. They stop drive-by abuse, not a determined person.

Step 2: the request, and two things that break in the browser

The request that powers the page, first in curl:

curl "https://api.apitube.io/v1/news/everything?language.code=en&is_duplicate=0&per_page=10&sort.by=published_at&sort.order=desc&fl=title,href,published_at,image,description,source.domain,source.favicon&api_key=YOUR_API_KEY"

One item from the results array, exactly as returned:

{
  "title": "The AlleyWatch Startup Daily Funding Report: 9/16/2026",
  "href": "https://alleywatch.com/2026/09/the-alleywatch-startup-daily-funding-report-9-16-2026/",
  "published_at": "2026-09-16T16:52:55.000Z",
  "image": "https://alleywatch.com/wp-content/uploads/2019/11/nyc_tech_startup_funding_daily-report_9-16.jpg",
  "description": "The latest venture capital, seed, pre-seed, and angel deals for NYC startups for 9/16/2026 featuring funding details for Stuut, Evvy, Footprint, Tare, and much more. This page will be updated throughout the. . .",
  "source": {
    "domain": "alleywatch.com",
    "favicon": "https://www.google.com/s2/favicons?domain=https://alleywatch.com"
  }
}

The fl parameter is the field list. Without it, each article arrives with body, body HTML, entities, sentiment, and 25 other keys the page never reads. We measured both variants 15 times each with curl:

Variant	Response size	Median time	p90 time
Full article objects, 10 items	238 KB	1.21 s	1.56 s
`fl=` with 7 fields, 10 items	9.5 KB	0.85 s	1.23 s

Two things bit us before the page rendered anything.

is_duplicate=false is a 400. The API wants 0 or 1 and answers ER0003 "Invalid is_duplicate value." otherwise. The page shows that code in its status line instead of a generic "something went wrong", because the error body is JSON with an errors[0].code and errors[0].message.

The key cannot go in a header. A custom header such as X-API-Key turns the request into a preflighted one, and the API's reply to the OPTIONS preflight currently carries Access-Control-Allow-Origin: * twice. Chrome refuses that with "contains multiple values '*, *'" and the fetch never happens. A plain GET with the key in the query string is a simple request, gets a single Access-Control-Allow-Origin: *, and works from any origin. That is what the file does. The same test with Authorization: Bearer fails the same way. We reported it; check the response headers before assuming it is still true when you read this.

One more limit: the API does not send Access-Control-Expose-Headers, so the page cannot read X-RateLimit-Remaining. If you want a counter, count your own requests.

Step 3: index.html

Replace YOUR_API_KEY, open the file, done. Ninety-seven lines including CSS.

<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Headlines</title>
<link rel="icon" href="data:,">
<style>
  body { margin: 0 auto; max-width: 720px; padding: 16px; font-family: system-ui, sans-serif; color: #111; background: #fafafa; }
  header { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
  h1 { font-size: 1.4rem; margin: 0 auto 0 0; }
  input, button { font: inherit; padding: 8px 10px; border: 1px solid #bbb; border-radius: 6px; background: #fff; }
  button { cursor: pointer; }
  #status { color: #666; font-size: .9rem; margin: 10px 0; }
  article { display: grid; grid-template-columns: 96px 1fr; gap: 12px; padding: 12px 0; border-top: 1px solid #e5e5e5; }
  article img { width: 96px; height: 72px; object-fit: cover; border-radius: 6px; background: #eee; }
  article h2 { font-size: 1rem; margin: 0 0 4px; }
  article h2 a { color: #0254EC; text-decoration: none; }
  article p { margin: 0 0 6px; font-size: .9rem; color: #444; }
  article small { color: #777; display: flex; gap: 6px; align-items: center; }
  article small img { width: 14px; height: 14px; }
</style>
</head>
<body>
<header>
  <h1>Headlines</h1>
  <input id="q" placeholder="Search titles…" aria-label="Search titles">
  <button id="go">Search</button>
  <button id="refresh" title="Refresh">↻</button>
</header>
<p id="status">Loading…</p>
<main id="list"></main>
<script>
// Option A: a key you accept being public (a test key, or a live key with
// referrer rules). Option B: leave API_KEY empty and point PROXY_URL at a
// Worker that holds the real key.
const API_KEY = "YOUR_API_KEY";
const PROXY_URL = "";                 // e.g. "https://news-proxy.you.workers.dev"
const ENDPOINT = PROXY_URL || "https://api.apitube.io/v1/news/everything";
const CACHE_TTL_MS = 15 * 60 * 1000;  // free plan: 100 requests/day
const FIELDS = "title,href,published_at,image,description,source.domain,source.favicon";

async function loadNews(title = "") {
  const params = new URLSearchParams({
    "language.code": "en", is_duplicate: "0", per_page: "10",
    "sort.by": "published_at", "sort.order": "desc", fl: FIELDS,
  });
  if (title) params.set("title", title);
  // The key goes in the query string, not in an X-API-Key header: a custom
  // header forces a CORS preflight, and the API's preflight reply currently
  // sends Access-Control-Allow-Origin twice, which Chrome rejects.
  if (API_KEY) params.set("api_key", API_KEY);
  const url = `${ENDPOINT}?${params}`;
  const cached = JSON.parse(sessionStorage.getItem(url) || "null");
  if (cached && Date.now() - cached.t < CACHE_TTL_MS) return cached.data;

  const res = await fetch(url);
  if (!res.ok) {
    const err = (await res.json().catch(() => ({}))).errors?.[0];
    throw new Error(err ? `${res.status} ${err.code}: ${err.message}` : `HTTP ${res.status}`);
  }
  const data = await res.json();
  sessionStorage.setItem(url, JSON.stringify({ t: Date.now(), data }));
  return data;
}

const list = document.getElementById("list");
const status = document.getElementById("status");
const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
const ago = (iso) => { const m = Math.round((Date.now() - new Date(iso)) / 60000); return m < 60 ? `${m} min ago` : `${Math.round(m / 60)} h ago`; };

function render(data) {
  list.innerHTML = data.results.map((a) => `
    <article>
      ${a.image ? `<img src="${esc(a.image)}" alt="" loading="lazy" onerror="this.style.visibility='hidden'">` : "<div></div>"}
      <div>
        <h2><a href="${esc(a.href)}" target="_blank" rel="noopener">${esc(a.title)}</a></h2>
        <p>${esc(a.description)}</p>
        <small><img src="${esc(a.source.favicon)}" alt="">${esc(a.source.domain)} · ${ago(a.published_at)}</small>
      </div>
    </article>`).join("");
  status.textContent = `${data.results.length} stories · updated ${new Date().toLocaleTimeString()}`;
}

async function show(title) {
  status.textContent = "Loading…";
  try { render(await loadNews(title)); }
  catch (e) { status.textContent = e.message; list.innerHTML = ""; }
}

document.getElementById("go").onclick = () => show(document.getElementById("q").value.trim());
document.getElementById("q").onkeydown = (e) => { if (e.key === "Enter") show(e.target.value.trim()); };
document.getElementById("refresh").onclick = () => { sessionStorage.clear(); show(document.getElementById("q").value.trim()); };
show();
</script>
</body>
</html>

Four decisions worth knowing about:

Every value goes through esc(). Headlines are untrusted input. A title containing <img onerror=…> would otherwise run in your page.
The cache key is the full URL. Search for "tesla" and you get a separate 15-minute bucket, so a second search for the same word costs nothing.
Images fail silently. In our run 8 of 10 stories carried an image and 5 of those 8 loaded. The rest were blocked by the publisher's Cross-Origin-Resource-Policy header. onerror hides the grey box instead of showing a broken icon.
Errors are the API's words. A 429 shows 429 ER0203: … in the status line, which tells you it is the rate limit and not your code.

On the free plan the description is a 200-character preview, per_page maxes out at 10, and articles arrive with a 12-hour delay. The "4 min ago" in the screenshot comes from a paid key; a free key shows "12 h ago" on everything. Say so in your UI or people will think the clock is broken.

Step 4: deploy to GitHub Pages

Create a repository, add index.html, push.
Settings → Pages → Source: "Deploy from a branch", branch main, folder / (root). Save.
Wait about a minute. The site is at https://YOUR-USER.github.io/REPO/.
If you used a live key, add that origin to the key's referrer rule now.

This is where most vanilla JS news app tutorials quietly die. They are written against an API that only allows browser calls from localhost, the page works during the tutorial, and the first deploy returns a CORS error. Unlike NewsAPI.org's Developer plan, which enables CORS for localhost only, APITube's free plan answers every origin with Access-Control-Allow-Origin: *, which means the same file keeps working after you deploy it. Check the free tier before you pick an API:

Provider, free tier	Browser calls from a deployed site	Delay	Requests/day
NewsAPI.org Developer	No: "CORS enabled for localhost" only	24 h	100
APITube Free	Yes: `Access-Control-Allow-Origin: *` on every GET (measured)	12 h	100

A second thing to know about GitHub Pages: it serves files as-is. There is no environment variable, no server-side include, nowhere to hide a string. That is why Step 1 exists.

Step 5: when the key must stay secret, a 35-line Worker

The free plan allows 100 requests a day. In direct mode every visitor's first load is one request, so 100 visitors empty the quota and visitor 101 sees 429 ER0203. The way out is a proxy that holds the key and caches the answer. Cloudflare Workers is the usual choice because the free tier covers it and the Cache API needs no configuration.

// worker.js — holds the real key; the page calls this URL instead of the API.
const ALLOWED_ORIGINS = ["https://YOUR-USER.github.io", "http://localhost:8000"];
const ALLOWED_PARAMS = new Set(["title", "language.code", "is_duplicate", "per_page", "page", "sort.by", "sort.order", "fl"]);
const CACHE_TTL = 900; // seconds. 86400 / 900 = 96 upstream calls a day, whatever the traffic.

export default {
  async fetch(request, env, ctx) {
    const origin = request.headers.get("Origin") || "";
    if (!ALLOWED_ORIGINS.includes(origin)) return new Response("forbidden", { status: 403 });
    const cors = { "Access-Control-Allow-Origin": origin, "Vary": "Origin" };
    if (request.method === "OPTIONS") return new Response(null, { status: 204, headers: cors });
    if (request.method !== "GET") return new Response("method not allowed", { status: 405, headers: cors });

    const upstream = new URL("https://api.apitube.io/v1/news/everything");
    for (const [k, v] of new URL(request.url).searchParams) {
      if (ALLOWED_PARAMS.has(k)) upstream.searchParams.set(k, v);
    }
    upstream.searchParams.sort();

    const cacheKey = new Request(upstream.toString());
    let res = await caches.default.match(cacheKey);
    let hit = "HIT";
    if (!res) {
      hit = "MISS";
      const up = await fetch(upstream, { headers: { "X-API-Key": env.APITUBE_API_KEY } });
      res = new Response(up.body, { status: up.status, headers: { "Content-Type": "application/json" } });
      res.headers.set("Cache-Control", `public, max-age=${CACHE_TTL}`);
      if (up.ok) ctx.waitUntil(caches.default.put(cacheKey, res.clone()));
    }
    res = new Response(res.body, res);
    for (const [k, v] of Object.entries(cors)) res.headers.set(k, v);
    res.headers.set("X-Proxy-Cache", hit);
    return res;
  },
};

Put the key in a secret (wrangler secret put APITUBE_API_KEY, or .dev.vars locally), set PROXY_URL in index.html to the Worker URL and API_KEY to an empty string. The Worker rebuilds the upstream URL from an allowlist of parameters, so a visitor cannot smuggle api_key= or an unrelated endpoint through it. The Cache-Control override matters: the API answers with no-store, and the Cache API refuses to store that.

We ran it with wrangler dev on a laptop rather than deploying to a Cloudflare account, so the timings are local:

Request	Result	Median time
Allowed origin, first call	200, `X-Proxy-Cache: MISS`	656 ms (12 different searches)
Allowed origin, repeat	200, `X-Proxy-Cache: HIT`	3 ms (12 runs)
Unknown origin, or no `Origin` header	403
`POST`	405
`?api_key=stolen` appended	200, parameter dropped

In headless Chrome the page showed its first headline 45 ms after load through the cached proxy, against 858 ms straight to the API.

The budget works out like this. With a 900-second TTL the default feed costs at most 96 upstream requests a day. Every distinct search term is its own cache entry with its own 96, so a search box on a free plan still needs a ceiling: cache longer, or only allow searches from a fixed list. Below 100 visitors a day, direct mode with a referrer-restricted key is fine and you skip the Worker entirely.

That is the whole decision. One HTML file is enough for the app; the number of requests a day you can afford decides whether the key sits in that file, in a referrer rule, or behind 35 lines of Worker. Copy index.html, pick the row of the table in Step 1 that matches your traffic, and push.

FAQ

How do you hide an API key in JavaScript on a static site?
An API key in client-side JavaScript cannot be hidden, because anything the browser sends the visitor can read in the network tab. The two working options are a key that is safe to expose (a test key, or a live key restricted to your domain and one endpoint) and a proxy such as a Cloudflare Worker that holds the real key and answers the page instead of the API.

Can a plain HTML file call a news API with fetch?
A plain HTML file can call a news API with fetch when the API sends Access-Control-Allow-Origin for your origin and the request stays simple: GET, no custom headers, the key in the query string. A custom auth header triggers a preflight, and for this API the preflight reply is currently malformed, so the header route fails in Chrome.

Which news API works from the browser on a free plan?
The news API that works from a deployed browser page on a free plan is one that sends Access-Control-Allow-Origin: * on every GET; APITube's free plan does, at 100 requests a day, 10 per minute, with a 12-hour delay on articles. NewsAPI.org's Developer plan restricts CORS to localhost, so it fails once deployed.

APITube is the API we used here; there is a free tier at apitube.io.

Resources

APITube docs: authentication, test keys, referrer rules
APITube docs: rate limits and plan ceilings
APITube docs: /v1/news/everything parameters
MDN: CORS, simple requests and preflight
Cloudflare Workers: Cache API
GitHub Pages: publishing from a branch
NewsAPI.org pricing (Developer plan: CORS for localhost)
Measurements: images/1-news-app-without-backend-one-html-file/data.csv

A week of NVIDIA news is 5,718 articles. My filter kept 161

APITube News API — Wed, 16 Sep 2026 04:55:08 +0000

I wanted a small script that pings me when something real happens to NVIDIA — an earnings surprise, an export-control change, a leadership move. Not a feed. A handful of lines a day I can actually read.

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 -H "X-API-Key: $APITUBE_API_KEY" \
  "https://api.apitube.io/v1/news/everything?title=nvidia&per_page=2&published_at.start=2026-08-30&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.

Strategy	Unique articles, 7 days	Share of entity-matched coverage
`title=nvidia`	1,831	29.8%
`entity.id=1280220`	5,538	100%
union of both	5,718	—

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	Rule	Articles / 7 days	Per day
1	Everything mentioning NVIDIA (union of both queries)	5,718	817
2	`language == "en"`	1,806	258
3	NVIDIA in the headline and `frequency >= 2`	679	97
4	Near-duplicates removed	594	85
5	Matched a watch theme	161	23

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|results|forecast",
    "leadership": r"\bceo\b|jensen huang|\bcfo\b|resign|steps down|appoint",
    "export":     r"export|sanction|china|\bban\b|restrict|licen[cs]e|blackwell|tariff",
    "legal":      r"lawsuit|sue[sd]?\b|antitrust|probe|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,
        "User-Agent": "nvidia-watch/1.0",   # urllib's default UA gets a 403
    })
    payload = json.load(urllib.request.urlopen(req, timeout=60))
    for w in payload.get("meta", {}).get("warnings", []):
        print("WARNING", w["code"], w["message"])   # a typo'd filter is ignored, not rejected
    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):
    words = re.sub(r"[^a-z0-9 ]", " ", (title or "").lower()).split()
    return " ".join(sorted(set(w for w in words if len(w) > 3)))

def watch(entity_id, keyword, start, end, language="en"):
    seen, out = set(), []
    for field in ("entity.id", "title"):                        # stage 1: union
        page = 1
        while True:
            q = {"published_at.start": start, "published_at.end": end, "page": page,
                 field: entity_id if field == "entity.id" else keyword}
            data = fetch(**q)
            rows = data.get("results", [])
            for a in rows:
                if a.get("language") != language:                              # stage 2
                    continue
                if not re.search(keyword, a.get("title") or "", re.I):         # stage 3a
                    continue
                if mentions(a, entity_id) < 2:                                 # stage 3b
                    continue
                key = normalise(a["title"])
                if key in seen:                                                # stage 4
                    continue
                blob = f"{a.get('title','')} {a.get('description','')}"
                if not THEME_RE.search(blob):                                  # stage 5
                    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")
    print(f"\n{len(hits)} alerts over 7 days ({len(hits)/7:.1f}/day)\n")
    for a in sorted(hits, key=lambda x: x["published_at"]):
        theme = next(t for t, p in THEMES.items()
                     if re.search(p, f"{a['title']} {a.get('description','')}", re.I))
        print(f"[{theme:10s}] {a['published_at'][:10]}  {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:

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.
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.
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 week of NVIDIA news is 5,718 articles. Our filter kept 161

APITube News API — Tue, 08 Sep 2026 17:37:09 +0000

We wanted a small script that pings us when something real happens to NVIDIA — an earnings surprise, an export-control change, a leadership move. Not a feed. A handful of lines a day we can actually read.

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

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 -H "X-API-Key: $APITUBE_API_KEY" \
  "https://api.apitube.io/v1/news/everything?title=nvidia&per_page=2&published_at.start=2026-08-30&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 us throw away version one. We ran the same week twice — once filtering on the headline, once on the canonical entity id.

Strategy	Unique articles, 7 days	Share of entity-matched coverage
`title=nvidia`	1,831	29.8%
`entity.id=1280220`	5,538	100%
union of both	5,718	—

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. We set it, because we 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	Rule	Articles / 7 days	Per day
1	Everything mentioning NVIDIA (union of both queries)	5,718	817
2	`language == "en"`	1,806	258
3	NVIDIA in the headline and `frequency >= 2`	679	97
4	Near-duplicates removed	594	85
5	Matched a watch theme	161	23

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|results|forecast",
    "leadership": r"\bceo\b|jensen huang|\bcfo\b|resign|steps down|appoint",
    "export":     r"export|sanction|china|\bban\b|restrict|licen[cs]e|blackwell|tariff",
    "legal":      r"lawsuit|sue[sd]?\b|antitrust|probe|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,
        "User-Agent": "nvidia-watch/1.0",   # urllib's default UA gets a 403
    })
    payload = json.load(urllib.request.urlopen(req, timeout=60))
    for w in payload.get("meta", {}).get("warnings", []):
        print("WARNING", w["code"], w["message"])   # a typo'd filter is ignored, not rejected
    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):
    words = re.sub(r"[^a-z0-9 ]", " ", (title or "").lower()).split()
    return " ".join(sorted(set(w for w in words if len(w) > 3)))

def watch(entity_id, keyword, start, end, language="en"):
    seen, out = set(), []
    for field in ("entity.id", "title"):                        # stage 1: union
        page = 1
        while True:
            q = {"published_at.start": start, "published_at.end": end, "page": page,
                 field: entity_id if field == "entity.id" else keyword}
            data = fetch(**q)
            rows = data.get("results", [])
            for a in rows:
                if a.get("language") != language:                              # stage 2
                    continue
                if not re.search(keyword, a.get("title") or "", re.I):         # stage 3a
                    continue
                if mentions(a, entity_id) < 2:                                 # stage 3b
                    continue
                key = normalise(a["title"])
                if key in seen:                                                # stage 4
                    continue
                blob = f"{a.get('title','')} {a.get('description','')}"
                if not THEME_RE.search(blob):                                  # stage 5
                    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")
    print(f"\n{len(hits)} alerts over 7 days ({len(hits)/7:.1f}/day)\n")
    for a in sorted(hits, key=lambda x: x["published_at"]):
        theme = next(t for t, p in THEMES.items()
                     if re.search(p, f"{a['title']} {a.get('description','')}", re.I))
        print(f"[{theme:10s}] {a['published_at'][:10]}  {a['title'][:70]}")

Standard library only. Running it just now returned 153 rather than the 161 in our 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 us time

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 us twenty minutes of blaming our API key.

Frequently asked questions

How do I get news alerts for a specific company?

Why do my company news alerts return irrelevant articles?

Can I filter news by ticker symbol?

How do you deduplicate news articles from multiple sources?

Is entity resolution enough on its own?

Making it yours

To point this at another company:

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.
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.
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 we counted what it threw away.

Disclosure: we 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

Stop Scraping: How to Integrate the World's Best News API into Your App

APITube News API — Sat, 14 Feb 2026 05:49:25 +0000

Data is the lifeblood of modern application development. Whether you are building a financial forecasting model, a brand monitoring dashboard, or an AI-driven market intelligence tool, the quality of your input data dictates the quality of your output. For years, developers faced a frustrating dilemma when it came to news data: either spend valuable engineering hours building and maintaining fragile web scrapers or settle for expensive, limited legacy APIs that offer stale data.

The landscape has changed. The era of manual scraping is over, replaced by intelligent, scalable, and affordable solutions designed specifically for developers.

In this guide, we are going to explore how to leverage the most robust tool currently on the market: APITube.io. We will dive deep into why this specific API has become the gold standard for engineering teams, the technical challenges its creators overcame to build it, and how you can integrate it into your Python, JavaScript, or Go applications in minutes.

The Engineering Challenge: Why Building a News Aggregator is Hard

To understand why APITube.io stands out, we first need to look at the massive engineering hurdle of aggregating global news.

When the team behind APITube first conceptualized the platform, they had a singular, ambitious goal: to create a "Google for News Data" that was accessible via a simple REST API. They wanted to democratize access to information, ensuring that a solo developer could access the same level of market intelligence as a Fortune 500 company.

However, the path to achieving this was fraught with technical complexities.

The Complexity of Scale

The internet generates terabytes of text data every hour. The creators of APITube faced the daunting task of indexing over 500,000 news sources. This wasn't just about major outlets like CNN or Bloomberg; the goal was comprehensive coverage, including niche blogs, local news from 200+ countries, and specialized industry publications.

The "Noise" Problem

One of the biggest struggles in data aggregation is filtering signal from noise. A raw feed of the internet is messy, filled with duplicates, spam, and paywalled content. The APITube engineering team had to build proprietary algorithms to de-duplicate stories in real-time and categorize them accurately. They faced the challenge of taking unstructured HTML from half a million different site architectures and normalizing it into a clean, consistent JSON format.

The Multilingual Barrier

Global business doesn't happen in just one language. To truly serve a global developer base, APITube had to solve the Natural Language Processing (NLP) challenge across 60 different languages. They needed to ensure that a sentiment analysis algorithm worked just as well on a Spanish financial report as it did on a Japanese tech review.

The Result: A Developer’s Dream

Despite these hurdles, the result was a triumph of software engineering. APITube succeeded in building a pipeline that processes millions of articles daily with near-zero latency. They achieved their goal of a unified API that handles the heavy lifting—scraping, parsing, cleaning, and analyzing—so you don't have to.

The platform they built is not just a data pipe; it is an intelligent engine that offers context, sentiment, and reliability. It is the solution that developers have been waiting for.

Why APITube.io is the Definitive Choice for Developers

There are other APIs on the market, but APITube has cornered the market on developer experience and data depth. Here is why it is the superior choice for your next project.

1. Unmatched Global Coverage

APITube doesn't just skim the headlines. It ingests data from over 500,000 sources across 177 countries. Whether you need hyper-local news from a specific region in Brazil or breaking tech news from Silicon Valley, the coverage is exhaustive.

This is critical for applications like Supply Chain Monitoring, where a local strike reported in a regional newspaper could be the first indicator of a global disruption. With APITube, you catch that signal.

2. AI-Powered Enrichment

Raw text is rarely enough. What makes APITube the industry leader is its use of Artificial Intelligence to enrich every single article that passes through its system.

Sentiment Analysis: The API automatically scores articles (positive, negative, neutral). This is game-changing for algorithmic trading bots that need to gauge market mood instantly.
Topic Modeling & Categorization: The system automatically tags content by industry, topic, and category, allowing for precise filtering.
Source Bias Detection: In an era of misinformation, APITube helps developers identify the political or reliable stance of a source, a feature rarely seen in competitor products.

3. Historical Data Access

Most APIs limit you to the last 30 days of data. APITube understands that predictive models need training data. They provide access to 10 years of historical data, allowing data scientists to backtest strategies or analyze long-term trends effectively.

4. Structured JSON Data Models

For a developer, the beauty of an API lies in its response structure. APITube delivers a standardized JSON object that is a joy to parse.

You don't just get a title and a link. You get:

read_time: Estimated minutes to read.
sentiment: The calculated emotional tone.
is_breaking: A boolean flag for urgent news.
entities: Extracted people, organizations, and locations.
is_paywall: Know before you click if the content is accessible.

How to Integrate APITube: A Practical Guide

Let’s get into the code. Integrating APITube.io is incredibly straightforward, adhering to standard REST principles.

Step 1: Get Your API Key

First, head over to the website and sign up. The onboarding process is frictionless. You can authenticate with GitHub or Google, and you will be in the dashboard in seconds. Grab your API Key from the settings.
fff

Step 2: Choose Your Integration

APITube supports virtually every modern language. Whether you are writing a backend in Go, a data script in Python, or a web app in JavaScript, they have you covered.

Step 3: Making Your First Request (Python Example)

Let’s say we want to build a simple script to monitor "Artificial Intelligence" news in the "Technology" sector, but we only want positive news stories to share on a company Slack channel.

Here is how simple that query is with APITube:

import requests

url = "https://api.apitube.io/v1/news/everything"

querystring = {
    "q": "Artificial Intelligence",
    "category": "technology",
    "sentiment_direction": "positive",
    "language": "en",
    "limit": "10",
    "api_key": "YOUR_API_KEY_HERE"
}

response = requests.request("GET", url, params=querystring)

data = response.json()

for article in data['results']:
    print(f"Title: {article['title']}")
    print(f"Sentiment: {article['sentiment']}")
    print(f"Link: {article['href']}")
    print("-" * 20)

What just happened?\
In less than 15 lines of code, we filtered millions of articles to find exactly what we needed based on topic, category, and emotional sentiment.

Step 4: leveraging Advanced Filters

The power of APITube lies in its granularity. You aren't limited to keyword searches. You can filter by:

Publisher Rank: Only get news from high-authority domains (e.g., BBC, NYT) to ensure credibility.
Location: Geofence your news to specific coordinates or countries.
Exclude Domains: Clean up your feed by blocking specific sites.

Real-World Use Cases: What Can You Build?

The versatility of APITube means it powers a wide variety of enterprise-grade applications. Here are a few ways developers are using it today.

Financial Intelligence and Algorithmic Trading

Hedge funds and fintech startups use APITube to feed NLP models. By monitoring real-time news on specific tickers (e.g., TSLA, AAPL) and analyzing the sentiment velocity, algorithms can execute trades milliseconds after breaking news hits the wire—often before the market fully reacts.

Crisis Management and PR

Public Relations firms use the API to build "Reputation Radars." By tracking brand mentions combined with sentiment analysis, they can receive alerts the moment negative news starts trending, allowing them to respond immediately. The is_breaking flag is particularly useful here for crisis containment.

Competitor Analysis Dashboard

Product managers use the API to automate competitive intelligence. You can set up streams to monitor competitor product launches, executive hiring (via "management change" triggers), or funding announcements. Instead of manually checking TechCrunch, the data comes to you.

Content Aggregation and Curation

Media companies use APITube to populate niche news feeds. A "Crypto News" app, for example, can be built entirely on the backend of APITube, filtering for cryptocurrency topics, removing duplicates, and presenting only high-readability score articles to users.

The Verdict: Why Developers Love APITube

After reviewing the capabilities, documentation, and performance, it is clear why the developer community has embraced this tool.

The team behind APITube set out to solve the problem of messy, inaccessible news data. They faced the challenges of scale, language, and noise head-on. The result is a platform that is robust, reliable, and incredibly easy to use.

Developers appreciate the transparency. The API documentation is comprehensive, with copy-paste examples for cURL, Python, PHP, Java, and more. The pricing is transparent, and the free tier allows for genuine testing and prototyping.

But most of all, developers appreciate the quality. In an ecosystem filled with broken scrapers and abandoned APIs, APITube works. It delivers clean, structured data every single time. It allows developers to stop worrying about data acquisition and start focusing on building great products.

Conclusion and Recommendations

If you are planning to integrate news data into your application, do not waste time reinventing the wheel. Building a scraper is a maintenance nightmare, and inferior APIs will only frustrate your users with irrelevant or duplicate content.

APITube.io has already done the hard work. They have indexed the world, cleaned the data, and wrapped it in a beautiful, AI-powered API.

Our Recommendations:

Start with the Free Plan: You can test the waters and see the JSON structure for yourself without a credit card.
Use the Filters: Don't just request "all news." Use the sentiment and category filters to make your application smarter.
Explore the Historical Data: If you are building AI models, the 10-year archive is an invaluable resource for training data.

Ready to build something powerful?

Get your free API Key at APITube.io today

Stop Drowning in Data: Find News by Industry, Topic, or Category Without Manual Filtering

APITube News API — Thu, 29 Jan 2026 05:46:35 +0000

We are living in an era of information overload. Every minute, hundreds of thousands of articles, blog posts, and reports are published online. For developers, data analysts, and business leaders, this sheer volume of data presents a paradox: we have access to more information than ever before, yet finding the right information has never been harder.

According to the 2024 Reuters Institute Digital News Report, nearly four in ten people (39%) now actively avoid the news, often citing that they feel overwhelmed or "worn out" by the sheer amount of information. If consumers are feeling this fatigue, imagine the struggle for businesses attempting to monitor global markets, track brand sentiment, or aggregate content for applications. The noise is deafening, and valuable insights are often lost in the static.

Manual filtering is no longer a viable option. It is slow, prone to human error, and simply cannot scale to meet the demands of the modern digital landscape. What the industry needs is a precision tool—a way to cut through the noise and extract only the signals that matter.

This is where Apitube.io enters the picture. It represents a paradigm shift in how we access and process global information, offering a streamlined, automated solution to find news by industry, topic, or category without the headache of manual sorting.

Apitube.io: A Revolutionary Solution for News Filtering

Apitube.io is not just another news aggregator; it is a comprehensive News API designed for the specific needs of developers and data-driven organizations. It serves as a bridge between the chaotic, unstructured web and your clean, organized application.

At its core, Apitube.io provides real-time access to a staggering network of information. It monitors more than 500,000 news sources across 177 countries and in 60 languages. Whether you are looking for a niche publication in a specific local dialect or a headline from a major global outlet like Bloomberg or TechCrunch, Apitube.io has it covered.

But the true revolution lies in its accessibility. Complex data extraction usually requires complex coding. Apitube.io flips this script by offering a simple, consistent, and easy-to-use REST API. It allows you to integrate structured news data into your Python, Java, or PHP applications in minutes, not months.

The Goal Behind Apitube.io: What Problem Does It Solve?

When the team behind Apitube.io set out to build this platform, they were driven by a singular, ambitious goal: to democratize access to global intelligence.

They recognized that while the internet is a goldmine of data, extracting that gold requires heavy machinery that most startups and even large enterprises lack. Building a web scraper from scratch is difficult; maintaining it as websites change their structures is a nightmare. Furthermore, analyzing that data for sentiment or categorizing it by industry requires sophisticated AI models that are resource-intensive to build.

Apitube.io aimed to solve the "noise vs. signal" problem. They wanted to create a tool where a user could ask for "Automotive Industry news in Germany with positive sentiment" and receive exactly that—clean, JSON-formatted data—instantly.

The specific objectives were clear:

Eliminate Manual Filtering: Automate the categorization of news so users don't have to read every headline.
Global Reach: Ensure that language barriers don't stop a business from understanding international markets.
Data Enrichment: Go beyond just the text by providing sentiment analysis, entity recognition, and trust scores.

The Journey of Apitube.io: Challenges and Triumphs

Building a platform capable of indexing the world's news in real-time is no small feat. The journey of Apitube.io has been defined by overcoming significant technical hurdles to deliver a seamless user experience.

The Challenge of Scale

One of the primary difficulties was handling the immense scale of data. Processing articles from half a million sources requires robust infrastructure. The system needs to distinguish between a breaking news story and a duplicate reprint, ensuring that API users aren't paying for the same content twice.

The Challenge of Quality

Another hurdle was quality control. The internet is full of spam and low-quality blogs. Apitube.io had to develop sophisticated algorithms to assign Source Reliability Scores and Content Quality Scoring. This ensures that when a financial analyst queries the API, they are getting data they can trust.

The Triumph of Structure

Despite these challenges, the result is a triumph of software engineering. Apitube.io successfully implemented AI-powered analysis that creates structured data out of chaos.

Smart Categorization: The platform can automatically detect if an article belongs to the "Finance," "Tech," or "Health" industry without manual tagging.
Sentiment Analysis: It successfully deployed NLP (Natural Language Processing) to tag articles as positive, negative, or neutral—a game-changer for brand monitoring.
Standardization: Perhaps the biggest victory is the standardization of data. No matter the source, the output format remains consistent, making integration incredibly smooth for developers.

Apitube.io: The Results So Far

The statistics surrounding Apitube.io speak volumes about its success and adoption. It has evolved into a powerhouse for data consumption.

Currently, the platform boasts a repository of over 3.69 billion total articles. This is not just a live feed; it is a massive historical archive that allows for deep-dive research and trend analysis over the past decade.

On a daily basis, the system is vibrant and active. With over 24,000 requests processed today alone and nearly 80,000 new articles added daily, the data freshness is unparalleled.

The platform has successfully integrated with the workflows of teams around the world. From Financial Analysis platforms that use the data to spot investment trends, to PR Agencies utilizing the "Reputation Management System" to track brand mentions, the results are tangible. Apitube.io is delivering on its promise to provide "Worldwide News API for Your products."

How Close Is It to Achieving Its Goals?

If the goal was to create the ultimate filter for the world's news, Apitube.io is incredibly close to perfection.

The platform offers over 65 different filters to refine search results. This level of granularity is exactly what the creators set out to achieve. You can filter by:

Industry & Category: Narrow down to Energy, Crypto, Sports, or 100+ other niches.
Location & Language: Target specific geographies (e.g., news from Brazil in Portuguese).
Sentiment: Filter out negative noise to focus on positive growth stories, or vice versa for risk management.
Source Rank: Filter by the authority of the publisher.

By enabling this level of precision, Apitube.io has effectively solved the problem of information overload for its users. It has transformed the "firehose" of the internet into a manageable, drinkable stream of information. The inclusion of features like Paywall Detection and Duplicate Detection further proves that the platform understands the nuances of modern content consumption.

Apitube.io: Customer Satisfaction & Feedback

The true measure of any product is what its users say about it. For Apitube.io, the feedback has been overwhelmingly positive, particularly regarding its reliability and ease of integration.

Jake Helmold, a journalist, describes the impact the tool has had on his workflow: "As a journalist, NEWS API has become an indispensable part of my research toolkit." This highlights that the tool isn't just for coders; it's for anyone who needs to find facts fast.

Spencer Chasmar praises the technical stability: "Highly reliable API with comprehensive documentation." For developers building applications that require 24/7 uptime, this reliability is non-negotiable.

Don Pippert highlights the flexibility that sets Apitube.io apart: "The customizability of API's query parameters is outstanding."

Other users, like Radjesh Kishna, note the efficiency gains: "NEWS API has streamlined our news gathering process, saving us time and resources."

These testimonials confirm that Apitube.io is not just working; it is delighting its customer base by solving their most pressing pain points—saving time and providing accurate data.

Apitube.io: An Overall Assessment

After reviewing the features, the data volume, and the user feedback, the assessment is clear: Apitube.io is the premier choice for news data integration.

It stands out from competitors by offering "Extended Article Data" that others often miss or charge exorbitant fees for. While basic APIs might give you a headline and a URL, Apitube.io provides Category, Sentiment, Summary, Publisher Rank, and Source Bias data right out of the box.

The pricing model is also designed to scale. From a Free Plan perfect for testing and development (200 requests/day) to a Corporate Plan designed for large-scale enterprise projects, the barrier to entry is low, but the ceiling for capability is high.

It is a tool that balances technical sophistication with user-friendly design. The "AI Powered" engine does the heavy lifting, leaving developers with clean, usable data.

Recommendations & Conclusion: Why Apitube.io Is the Future of News Consumption

If your business relies on knowing what is happening in the world—whether for competitive intelligence, financial modeling, or content creation—you cannot afford to rely on manual searching or inferior scraping tools.

We highly recommend Apitube.io for the following use cases:

For Startups: Use the Free News API to build your MVP without incurring high costs.
For Financial Tech: Leverage the historical data and sentiment analysis to build predictive market models.
For Marketing Agencies: Utilize the brand monitoring features to track client reputation across 177 countries.

The era of "infobesity" is here, but with tools like Apitube.io, you don't have to drown in the data. You can harness it. By automating the filtering process by industry, topic, and category, you free up your team to focus on what matters: analyzing insights and making decisions.

Don't waste time on complex features or manual sorting. Experience the power of structured global intelligence today.

Get started for free at https://apitube.io

Best News API in 2026: The Ultimate Guide for Developers

APITube News API — Thu, 29 Jan 2026 05:38:41 +0000

Data is the lifeblood of modern innovation. As we navigate 2026, the demand for real-time information has transitioned from a luxury to an absolute necessity. Whether you are building financial models that react to market shifts in milliseconds, training Large Language Models (LLMs) on current events, or creating a media monitoring platform for PR firms, the quality of your output depends entirely on the quality of your input.

This is where News APIs come into play. These tools act as the bridge between the chaotic, sprawling world of global media and your structured application. However, not all APIs are created equal. The landscape has evolved significantly over the last few years, with a heavier emphasis on AI-ready data, sentiment analysis, and hyper-local coverage.

In this guide, we will explore the best News APIs available in 2026, aiming to help you find the perfect solution for your project. We will look at the goals behind these platforms, the challenges they solve, and ultimately, which one stands out as the premier choice for developers and businesses alike.

The Evolving Landscape of News APIs

Gone are the days when a simple RSS feed was sufficient. In 2026, the volume of content produced daily is staggering—billions of articles, blog posts, and reports are published every 24 hours. For developers, this presents a unique challenge: How do you filter the signal from the noise?

The modern landscape requires APIs that offer more than just headlines. Today's applications demand:

Structured Data: JSON formats that are clean, consistent, and easy to parse.
Deep Metadata: Information on author, sentiment, reading time, and entity recognition.
Global Reach: It is no longer enough to monitor the US and UK; businesses need insights from Brazil, Japan, Nigeria, and beyond.

Key Objectives for Using News APIs in 2026

Before we dive into the tools, it is vital to understand why organizations are prioritizing news integration this year.

Market Intelligence and Financial Analysis

Traders and analysts use news APIs to feed algorithmic trading bots. A split-second delay in receiving news about a merger or a regulatory change can cost millions. In 2026, the objective is low latency and high accuracy.

Risk Management

Supply chain disruptions and geopolitical instability require constant monitoring. Companies use these APIs to build early warning systems that alert them to risks in specific regions or industries before they hit the mainstream news cycle.

AI and LLM Training

With the explosion of generative AI, developers need vast amounts of high-quality, diverse, and recent text data to fine-tune models and prevent "knowledge cutoffs." News APIs provide the fresh context these models need to remain relevant.

Challenges and Opportunities in Integration

Integrating a news feed might sound simple, but the reality involves overcoming several hurdles.

The Challenge of Volume
Ingesting data from hundreds of thousands of sources can overwhelm standard databases. You need an API that handles the heavy lifting of aggregation and deduplication on their side, delivering only what you need.

The Challenge of Standardization
Every news site formats its HTML differently. One of the biggest opportunities for developers is finding an API that standardizes this mess into a clean body, title, and date format, regardless of whether the source is a major publication like The New York Times or a niche technology blog.

The Opportunity of Enrichment
The best APIs don't just deliver text; they enrich it. They tell you if an article is positive or negative (sentiment), they identify the people mentioned (Named Entity Recognition), and they categorize the topic automatically. This allows you to build smarter apps with less code.

Detailed Review of Top News APIs

Here is a look at the leading players in the market this year. We have evaluated them based on coverage, ease of use, and feature sets.

1. APITube.io (Top Recommendation)

When looking for the definitive leader in 2026, APITube.io stands apart from the crowd. To understand why it is the best, we have to look at the philosophy behind its creation.

The Goal:
The creators of APITube set out with a massive ambition: to democratize access to global information. Their goal was to build a "Worldwide News API" that didn't just scrape headlines but provided a comprehensive window into global events for products of all sizes. They wanted to strip away the complexity of data engineering so developers could focus on building.

The Journey and Challenges:
Building a system capable of monitoring 500,000+ news sources in real-time is no small feat. The team faced the immense technical challenge of normalizing data from 177 countries and 60 languages. They had to ensure that a query for "renewable energy" returned relevant results from a blog in Germany just as quickly as a major outlet in the US.

They also tackled the "noise" problem. Instead of just dumping data on users, they integrated AI-powered features like Sentiment Analysis, Duplicate Detection, and Paywall Detection.

The Result:
The result is a platform that feels effortless to use. APITube has succeeded in creating a simple, consistent, and easy-to-use REST API that delivers powerful results. They have achieved their goal of making global media computable.

Why We Love It:

Unmatched Coverage: Access to over 500,000 sources. Whether you need mainstream media or niche publications, it is all there.
Global Perspective: With support for 60 languages, you aren't limited to the English-speaking world.
Structured Intelligence: The JSON response is incredibly clean. You get fields for sentiment, industry, location, and even read_time.
Developer Friendly: It integrates in minutes with Python, Java, PHP, Go, and more.

The Verdict:
The team behind APITube should be incredibly proud. They have built a tool that solves the hardest parts of news aggregation. It is robust, reliable, and exactly what modern developers need.

2. The GDELT Project

The GDELT Project (Global Database of Events, Language, and Tone) is a research-focused initiative.

Overview:
GDELT monitors the world's broadcast, print, and web news from nearly every corner of every country. It is a massive open dataset that updates every 15 minutes.

The Experience:
GDELT is known for its scale. It translates coverage from 65 languages and is deeply integrated with Google BigQuery. However, it is primarily designed for academic research and large-scale geopolitical analysis. For a standard commercial developer, the learning curve can be steep, and the data often requires significant cleaning and processing before it can be used in a consumer-facing application.

3. The Guardian Open Platform

For developers looking specifically for content from the UK, The Guardian offers its own API.

Overview:
This API gives you access to the archives of The Guardian and The Observer, dating back to 1999.

The Experience:
The content quality is undeniably high, reflecting the journalistic standards of the publication. It allows for searching by tag, section, and date. However, the limitation is inherent in the name: it is a single-source API. If your application requires a diverse range of perspectives or global coverage outside of The Guardian's reporting, this tool will not suffice as a standalone solution.

4. NYT Developer Network

Similar to The Guardian, The New York Times provides an API for its content.

Overview:
This API allows you to retrieve articles, book reviews, and movie reviews from the NYT archives.

The Experience:
It is a functional tool for retrieving specific metadata and links to NYT articles. It is useful for displaying specific headlines or searching the paper's history. Like other single-publisher APIs, it does not offer the aggregation capabilities, sentiment analysis across multiple sources, or the global breadth required for market intelligence or comprehensive media monitoring.

Evaluation Criteria

When we compared these APIs, we focused on three core pillars essential for 2026 development standards.

1. Accuracy and Data Freshness

In a 24-hour news cycle, old news is no news. A top-tier API must deliver articles moments after they are published. APITube.io excels here with real-time updates, ensuring that if a story breaks in Tokyo, you have it in your database immediately.

2. Customization and Filtering

You don't want a firehose; you want a curated stream. The best APIs offer granular filtering. We looked for the ability to filter by date, category, source rank, and sentiment. APITube leads the pack here with over 65 filters, allowing you to drill down into very specific queries like "positive sentiment articles about crypto in Spanish."

3. Ease of Integration

Time-to-market matters. We evaluated how quickly a junior developer could get a "Hello World" response. RESTful architecture, clear documentation, and SDKs for major languages (Python, JS, Ruby, etc.) were key requirements.

Success Stories: Organizations Benefiting from News APIs

The true test of an API is how it performs in the wild. Here are a few examples of how professionals are using these tools to drive success.

The Journalist's Toolkit

Jake Helmold, a professional journalist, notes that using a robust news API has become an "indispensable" part of his research toolkit. By automating the gathering of sources, journalists can spend less time searching and more time verifying and writing.

Streamlining Content Delivery

Andrew Price found that integrating a news API streamlined his content delivery process. For media companies, this means being able to populate feeds and content aggregators automatically, keeping audiences engaged without manual curation.

Scalable Business Solutions

For businesses, scalability is key. J Silo reported that these tools offer scalable solutions for businesses of all sizes. Whether you are a startup building an MVP or an enterprise processing millions of requests, the right API grows with you.

Overcoming Complexities and Optimizing API Usage

To get the most out of your chosen news API, consider these optimization strategies:

Use Caching Wisely
Even with high rate limits, it is inefficient to request the same data repeatedly. Cache your responses. If you are building a "Top Headlines" widget, you likely only need to refresh it every 10-15 minutes, not every time a user refreshes the page.

Leverage Boolean Search
Don't settle for simple keyword matches. Use Boolean logic (AND, OR, NOT) to refine your results. For example, (Apple OR Microsoft) AND NOT "Fruit" ensures you get tech news, not agricultural reports.

Monitor Your Usage
Keep an eye on your credit consumption. Platforms like APITube provide clear analytics on your request volume, helping you understand your traffic patterns and scale your plan accordingly.

Final Thoughts and Recommendations

As we move further into 2026, the ability to access, filter, and analyze global news in real-time is a superpower for developers. While there are several options available for specific niches, one platform offers the comprehensive, all-in-one solution that modern applications require.

Recommendation:
For its sheer breadth of coverage (500,000+ sources), ease of use, and advanced AI-powered features, APITube.io is our top pick. The team behind it has successfully navigated the complexities of global data aggregation to provide a tool that is a joy to use.

Whether you are building the next big financial algorithm or simply want to display industry news on your company dashboard, APITube provides the reliability and depth you need.

Ready to start building?
Get your free API key at APITube.io and see what you can create with the world's news at your fingertips.