DEV Community: APITube News API

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

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

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.

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.

Why Smart Developers Are Ditching Web Scraping for APIs

APITube News API — Tue, 27 Jan 2026 06:18:17 +0000

If you’ve ever built a data-driven application, you know the drill. You find the perfect source of information—maybe it’s a news site, a financial portal, or a social media feed—and you think, "I just need to get this data into my app."

For years, the go-to solution for many developers was web scraping. It felt like a rite of passage: write a script, parse some HTML, and voilà, you have your data. But let's be honest—web scraping is often a messy, fragile, and legally gray endeavor. It’s a bit like trying to fix a leaky pipe with duct tape; it might hold for a while, but eventually, the pressure is going to cause a burst.

Smart developers today are realizing that "good enough" isn't good enough anymore. They need reliability, speed, and legal peace of mind. That’s why there is a massive shift happening in the development community: the move from custom web scrapers to robust, structured APIs.

In this guide, we’ll explore why this transition is happening, the specific headaches developers are leaving behind, and how tools like APITube.io are changing the game for data integration.

The Developer's Goal: Data Without the Drama

When a developer sets out to integrate external data, their goal is usually straightforward. They want to enhance their product with valuable information to solve a user problem.

Imagine you are building a financial analysis dashboard. Your users need real-time news updates to make investment decisions. Your goal isn't to build a news crawler; your goal is to display news so your users can analyze it.

Or perhaps you are creating a media monitoring tool for PR professionals. You need to know every time a specific brand is mentioned across thousands of blogs and news sites. Your value proposition is the insight, not the mechanism of fetching the HTML.

In these scenarios, the developer's motivation is efficiency and reliability. You want a pipeline that flows smoothly, delivering clean, structured data (JSON or XML) directly into your application logic. You don't want to spend your time fighting with <div> tags or debugging why your scraper failed at 3:00 AM.

This is where the promise of APIs shines. An API (Application Programming Interface) is a contract. The provider promises to deliver specific data in a specific format, and you promise to ask for it in a specific way. It’s a handshake, not a hack.

Platforms like APITube.io are built specifically to fulfill this need. They do the heavy lifting of aggregation and structuring so you can focus on building your product.

The Reality of Web Scraping: A Developer's Nightmare

If APIs are the dream, web scraping often turns into a nightmare. Let’s look at the specific challenges developers face when they choose the scraping route.

1. The Fragility of the DOM

Websites are designed for humans, not robots. A website owner might decide to redesign their homepage, change a CSS class name, or switch from server-side rendering to a heavy client-side JavaScript framework like React or Vue.

For a web scraper, these changes are catastrophic. A script that worked perfectly yesterday might return null or throw errors today because the HTML structure changed. This forces you into a reactive cycle:

The site updates.
Your app breaks.
You spend hours debugging and rewriting selectors.
Repeat next week.

2. The IP Ban Whack-A-Mole

Most major websites have defenses against scrapers. If you make too many requests from the same IP address, you’ll get blocked. To get around this, you have to manage proxy rotation, user-agent spoofing, and solve CAPTCHAs.

Suddenly, you aren't just building a data parser; you're building a complex infrastructure just to act like a human. This adds latency, cost, and significant complexity to your codebase.

3. The Legal Gray Area

This is the big one that corporate legal teams worry about. Web scraping often violates a website's Terms of Service (ToS). While the legality of scraping public data is still being debated in courts around the world, the risk is undeniable.

If you build your entire business model on scraping a competitor or a major publisher without permission, you are building on quicksand. Cease-and-desist letters are real, and they can shut down a project overnight.

4. Unstructured Chaos

Even when scraping works, the output is raw text or HTML. You have to write complex logic to clean it up.

Is that date format DD/MM/YYYY or MM/DD/YYYY?
Did the author's name get mixed up with the byline?
Why is the article body truncated?

Turning raw HTML into a clean database entry requires constant maintenance and rigorous testing.

The Joy of APIs: Stability, Structure, and Speed

Now, contrast that scraping experience with using a dedicated news API. When you switch to a provider like APITube.io, the friction disappears.

1. Structure by Default

APIs deliver structured data. When you request a news article, you don't get a blob of HTML; you get a JSON object with clear keys:

title
published_at
author
sentiment (often pre-calculated for you!)
content

You don't have to guess where the data is. It's exactly where the documentation says it will be. This makes integration trivial—often just a few lines of code in Python, JavaScript, or whatever language you prefer.

2. Legal Compliance and Peace of Mind

API providers have already done the work of sourcing data legitimately. When you pay for an API subscription, you are paying for the right to use that data. You don't have to worry about a lawsuit because you hit a server too hard or ignored a robots.txt file. The API provider handles the sourcing relationships and compliance.

3. Advanced Features Out of the Box

This is where smart developers really see the value. A scraper gets you the text, but an API often gives you intelligence.

Take APITube.io for example. It doesn't just give you the news; it enriches it.

Sentiment Analysis: Is this article positive, negative, or neutral?
Topic Modeling: What is this article actually about? (e.g., Finance, Tech, Sports)
Duplicate Detection: Do you really need to see the same AP wire story reprinted on 50 different sites? An API can filter that noise out for you.
Translation: Accessing news in 60 languages allows you to build truly global applications without needing a localization team.

4. Scalability

Scrapers don't scale well. If you need to scrape 10 pages, it takes X seconds. If you need to scrape 1 million pages, you need a massive distributed system.

With an API, scaling is usually just a matter of upgrading your plan. You can go from 100 requests a day to 100,000 without changing a single line of your code. The infrastructure is someone else's problem.

Real-World Results: What Happens When You Switch?

Let’s look at a hypothetical scenario based on real feedback from developers who have made the switch.

The "Before" State:\
A startup team was building a market intelligence platform. They spent 40% of their engineering time maintaining a fleet of scrapers. Every time a major news outlet updated their layout, their dashboard would go blank, leading to angry customer emails. Their "data scientists" were actually spending most of their time acting as "data janitors," cleaning up messy HTML parses.

The Switch:\
They decided to integrate APITube.io to handle their news feed.

The "After" State:

Development Time: The integration took less than a day.
Maintenance: Reduced to near zero. The API just works.
Data Quality: They instantly gained access to 500,000 sources, far more than they were scraping manually.
New Features: Because the API provided sentiment scores, they were able to launch a new "Market Mood" feature in their app within a week—something that would have taken months to build themselves.

The result? The developers were happier because they were building features, not fixing broken scripts. The business owners were happier because their product was more reliable and had better data. And the legal team breathed a sigh of relief.

Developer Satisfaction: A Clear Winner

If you browse developer forums or talk to CTOs, the consensus is clear. While web scraping is a useful skill for one-off tasks or academic research, it is not a foundation for a serious business.

Developers who switch to APIs report significantly higher satisfaction levels. They feel more productive. They spend less time on "grunt work" and more time on "logic work."

There is a distinct joy in reading clear documentation, sending a request, and getting a perfect 200 OK response with exactly the data you need. It feels professional. It feels secure.

Why APITube is the Smart Choice

If you've decided that an API is the way to go, the next question is: "Which one?"

APITube.io stands out for several reasons that appeal directly to the "smart developer" mindset:

Massive Reach: Access to over 500,000 sources in 177 countries.
Multilingual: Native support for 60 languages means you aren't limited to English-speaking markets.
Historical Data: Need to backtest a trading strategy? You can access 10 years of historical news data.
Smart Filtering: With over 65 filtering parameters, you can drill down to exactly what you need—whether it's "crypto news from Brazil in Portuguese" or "tech news about AI with positive sentiment."

How to Get Started

Getting started with an API is incredibly simple compared to writing a scraper.

Registration: Sign up and get your free API key.
First Request: You can make your first call in minutes. Here is a conceptual example of how easy it is to get the latest news about "Artificial Intelligence":

import requests

url = "https://api.apitube.io/v1/news/everything"
querystring = {
    "q": "Artificial Intelligence",
    "language": "en",
    "api_key": "YOUR_API_KEY"
}

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

That’s it. No parsing HTML. No proxies. Just data.

Summary and Recommendations

The era of "move fast and break things" is evolving into "move fast and build stable things."

Web scraping had its time, but for modern, data-driven applications, it is simply too costly in terms of maintenance, risk, and developer sanity.

Recommendation:\
If your application relies on news data, blog posts, or media monitoring, stop building scrapers. It is a sunk cost trap.

Instead, leverage a dedicated news API. You will gain:

Reliability: Uptime you can trust.
Efficiency: Structured data ready for use.
Intelligence: Built-in sentiment and topic analysis.
Scale: Global coverage without the infrastructure headache.

For a solution that offers a perfect balance of power, ease of use, and comprehensive coverage, we highly recommend checking out APITube.io. It’s the tool that smart developers are using to power the next generation of intelligent applications.

Don't let a broken scraper slow you down. Switch to an API and start building what matters.

Your News Scraper Just Broke Again? Here's the Real Solution

APITube News API — Tue, 27 Jan 2026 06:05:03 +0000

It’s 2:00 AM. Your monitoring dashboard is flashing red. The beautiful, custom-built Python script you deployed last week—the one designed to aggregate breaking financial news for your trading algorithm—has crashed. Again.

You dig into the logs and see the dreaded error messages. Maybe the target website changed a div class name. maybe Cloudflare decided your requests look suspicious and threw up a CAPTCHA. Or perhaps the site simply updated its layout, rendering your meticulously crafted CSS selectors useless.

This scenario is the bane of every developer who relies on web scraping for news data. You wanted a stream of information, but what you got was a second job maintaining fragile code. The internet is dynamic; websites are designed for humans, not robots. When you try to force raw HTML into structured data using brittle scripts, you are fighting a losing battle against the natural evolution of the web.

But it doesn't have to be this way. There is a difference between "scraping" and "data acquisition." One is a constant game of cat-and-mouse; the other is a reliable infrastructure strategy. If you are tired of patching broken scrapers, it's time to look at the real solution.

Why News Scrapers Break (It’s Not Just Bad Code)

When a scraper fails, it’s easy to blame the code. "I should have used a better selector," or "I need to rotate my user agents more frequently." While optimization helps, the fundamental problem isn't usually the script itself—it's the environment it operates in.

The Dynamic Web

Modern news websites are no longer static HTML pages delivered from a server. They are complex Single Page Applications (SPAs) built with React, Vue, or Angular. content is loaded dynamically via JavaScript. If your scraper is just making a simple GET request, it might see an empty page because the content hasn't rendered yet.

Anti-Scraping Defenses

Publishers are protective of their content. To prevent server overload and protect intellectual property, they employ sophisticated anti-bot measures. These systems look for:

High request rates: Too many hits from one IP address in a short time.
Browser fingerprinting: inconsistencies in your HTTP headers or TLS handshakes that reveal you aren't using a real browser.
Behavioral analysis: Mouse movements (or lack thereof) that don't match human patterns.

Structural volatility

News sites are constantly A/B testing. They change layouts to optimize ad revenue or user engagement. A slight change in the DOM structure—renaming a class from .article-body to .story-content—is enough to break a regex or BeautifulSoup parser instantly.

Common "Solutions" and Why They Fail

When faced with these challenges, developers often try to bandage the wound rather than cure the disease. Here are the typical band-aid solutions and why they eventually peel off.

1. The Regex Warrior

Regular Expressions (Regex) are powerful for text searching, but using them to parse HTML is a cardinal sin in programming. HTML is not a regular language. As soon as the nesting depth changes or a new attribute is added to a tag, your regex breaks. It is fragile, unreadable, and impossible to maintain at scale.

2. The Simple Library (BeautifulSoup/Cheerio)

Libraries like BeautifulSoup (Python) or Cheerio (Node.js) are excellent for parsing static HTML. However, they cannot execute JavaScript. As mentioned earlier, if the news site loads content via AJAX after the initial page load, these libraries will scrape nothing but empty containers.

3. The "Rotating Proxy" Fix

"My IP got banned? I'll just buy a pool of proxies!" While necessary, proxies alone aren't enough. If your scraper leaks its identity through headers or behaves robotically, you will still get blocked, just from a different IP address. Plus, managing proxy rotation, health checks, and costs is an infrastructure nightmare in itself.

The Real Solution: Robust Scraping Infrastructure

To get reliable news data, you need to stop thinking about scripts and start thinking about infrastructure. A robust solution isn't just code that grabs text; it's a system that mimics human behavior, adapts to changes, and handles the heavy lifting of rendering.

This is where the distinction between "building" and "buying" becomes critical. A true enterprise-grade scraping infrastructure involves several complex layers working in unison.

Key Components of a Robust Solution

If you were to engineer the "perfect" scraper that never breaks, here is what you would need to build and maintain:

Headless Browsers

You need to run actual browsers (like Chrome or Firefox) in headless mode (without a UI) using tools like Puppeteer, Playwright, or Selenium. This allows you to render JavaScript, wait for network idle states, and interact with the page just like a user would. This solves the SPA problem but introduces significant CPU and memory overhead.

Intelligent Proxy Networks

You cannot rely on datacenter proxies (AWS, DigitalOcean IPs) because they are easily flagged. You need residential proxies—IP addresses assigned to real home devices. Furthermore, you need logic to rotate them intelligently based on the target site’s sensitivity and geolocation requirements.

CAPTCHA Solvers

Eventually, you will hit a CAPTCHA. A robust system needs an automated way to solve or bypass these challenges, often integrating with third-party solving services or using AI to recognize the puzzles.

AI-Driven Parsing

This is the frontier of scraping. Instead of hard-coding CSS selectors (div.content > p), you use Machine Learning models trained to visually identify the "headline," "author," and "body" of an article regardless of the underlying HTML structure. This makes the scraper resilient to layout changes.

Building vs. Buying: The Economics of Data Acquisition

So, you have two choices: build this infrastructure yourself, or use a dedicated API.

The "Build It Yourself" Path

Pros:

Full control over the code.
No per-request cost (excluding server/proxy costs).

Cons:

Hidden Costs: You aren't just paying for servers; you are paying for the engineering time to maintain the scrapers.
Scalability Issues: Spinning up thousands of headless browsers requires massive compute resources.
The "Whack-a-Mole" Factor: You will spend your mornings fixing broken parsers instead of building your product.

The "Managed API" Path

Pros:

Reliability: The provider handles the anti-bot bypasses and DOM changes.
Structured Data: You get clean JSON, not raw HTML.
Focus: You spend time analyzing data, not acquiring it.

Cons:

Direct Cost: You pay a subscription fee.

For most businesses and developers, the opportunity cost of building and maintaining a scraper far outweighs the cost of a subscription to a dedicated News API.

How APITube.io Solves This

This is where APITube.io enters the picture. We didn't just build a scraper; we built a global intelligence engine. We realized that developers need consistency, not just raw access.

1. Global Reach, Zero Maintenance

APITube aggregates news from over 500,000 sources across 177 countries in 60 languages. Whether you need financial news from Bloomberg or local reports from a small outlet in Austria, we have it indexed. You don't need to write a single line of code to handle the scraping logic for these half-million sources.

2. Structured, Normalized Data

We turn the chaos of the web into order. When you make a request to our API, you don't get HTML. You get a clean, standardized JSON response containing:

Title and Body: Cleanly extracted text.
Sentiment Analysis: AI-driven scoring (Positive/Negative/Neutral).
Entities: Extracted people, organizations, and locations.
Multimedia: Links to images and videos.

3. Advanced Filtering

Instead of scraping a homepage and filtering the results yourself, APITube lets you filter before you fetch. You can query by:

Category: Tech, Business, Sports, etc.
Sentiment: Only show me negative news about Competitor X.
Date and Location: What happened in Paris last Tuesday?

4. Enterprise-Grade Reliability

We handle the proxies, the headless browsers, and the parsing logic. If a source changes its layout, our system adapts. You just consume the API endpoint, and the data flows.

Case Studies: Success Stories from the Field

Real businesses are already moving away from brittle scrapers to APITube's robust API.

The Financial Analyst's Edge\
Zhao Yi's analytics team was spending 40% of their time fixing Python scripts that scraped market news. By switching to APITube, they automated their trend analysis dashboard. "Our analytics team relies on NEWS API for accurate trend analysis," Zhao reports. They now focus on building predictive models rather than parsing HTML.

Journalism in Real-Time\
For journalists like Jake Helmold, speed is everything. Waiting for a scraper to finish a batch job isn't an option. "As a journalist, NEWS API has become an indispensable part of my research toolkit," says Jake. The ability to search through historical data (up to 10 years back) and receive real-time updates allows for deeper, faster reporting.

Seamless Integration for Developers\
Chris Bates needed to integrate news feeds into a mobile app quickly. Building a backend scraper would have delayed the launch by months. "Great and quick integration with APITube!" Chris noted. Using our SDKs for Python, JavaScript, or Java, developers can get their first request working in under 5 minutes.

The Future of News Scraping

The cat-and-mouse game between scrapers and websites will only get harder.

AI-Generated Content & Detection\
As the web fills with AI-generated content, distinguishing valuable news from noise will be the next major challenge. Simple scrapers won't be able to tell the difference. Advanced APIs like APITube are already implementing AI to detect and categorize content quality.

Semantic Search\
Keyword matching is becoming obsolete. The future is vector search—understanding the meaning behind a query, not just the text. "Show me news about Apple" shouldn't just return results with the word "Apple," but should understand if you mean the fruit or the tech giant based on context.

Stop Fixing, Start Building

You faced a clear goal: getting reliable news data to power your product or analysis. You faced the difficulties of IP bans, broken selectors, and maintenance nightmares. The result of doing it yourself is often frustration and wasted time.

The result of using a dedicated solution like APITube is reliability. You get closer to your goal of data-driven insights without the headache of infrastructure management.

If your scraper broke again today, take it as a sign. Stop fighting the internet.

Ready to switch to a solution that works?\
Sign up for APITube today and get your free API key. Make your first request in minutes and see the difference between broken code and structured data.

Stop Scraping: How One API Unlocks 500,000+ News Sources Instantly

APITube News API — Tue, 27 Jan 2026 05:57:33 +0000

Building a data-driven application is an exciting journey. You have a vision of a dashboard that predicts stock market trends based on global events, or perhaps a media monitoring tool that alerts brands the second they are mentioned online. The goal is clear: you want to ingest the world's information and turn it into actionable insights.

However, developers and data scientists often hit a massive wall immediately after starting. The internet is a messy, unstructured place. To get the data you need, you might start by writing a web scraper. It works for one site. Then you add another. Then another. Suddenly, you realize that to get a truly global perspective, you need to integrate with thousands of sources.

The reality of maintaining hundreds—let alone thousands—of individual integrations is a logistical nightmare. This blog post explores the journey from the frustration of manual data collection to the relief of finding a unified solution. We will look at how a single tool, APITube, can replace 500,000 individual integrations, allowing you to focus on building your product rather than fixing broken scrapers.

The Goal: Global Coverage Without the Headache

When you set out to build a market intelligence platform or a news aggregator, the objective is usually ambitious. You aren't satisfied with just checking the New York Times or the BBC. You want the long-tail data. You want to know what local newspapers in Brazil are saying about agricultural exports, or what tech blogs in Japan are saying about robotics.

The target is comprehensive situational awareness. To achieve this, your data pipeline needs to be:

Real-time: Yesterday’s news is history, not data.
Multilingual: Business happens in every language, not just English.
Structured: You need clean JSON, not messy HTML soup.

The ambition is high. You want to create a system where a user can type a query and instantly receive relevant articles from 177 countries. But as many developers discover, the gap between "I want this data" and "I have this data" is filled with technical obstacles.

The Struggle: The Reality of Web Scraping

If you have ever tried to build your own news aggregator from scratch, you know the pain. You start with Python and Beautiful Soup or Selenium. You write a script to scrape a popular tech news site. It works perfectly—for three days.

Then, the site updates its DOM structure. Your script breaks. You fix it.

Next, you get blocked. The site realized you were a bot and banned your IP address. Now you need to manage a proxy rotation service.

Then comes the CAPTCHA. You need a solver service.

Now multiply this process by 500,000. It is statistically impossible for a single team to maintain custom scrapers for 500,000 news sources. The "joy" of coding quickly turns into the misery of maintenance. You aren't building an AI product anymore; you are just a digital janitor cleaning up broken links and managing server errors.

This is the "build vs. buy" dilemma at its most extreme. The difficulty isn't just getting the data; it's the sheer unpredictability of the sources.

The Solution: A Unified Gateway to the World's News

This is where the concept of a News API changes the game. Instead of building the infrastructure to go out and fetch the news, you simply connect to a service that has already done the heavy lifting.

APITube acts as a single access point to over 500,000 news sources. It standardizes the chaos of the web into a clean, consistent format.

How it works

Imagine replacing half a million lines of custom scraping code with a single REST API call. That is the core value proposition here. You send a request specifying what you are looking for—keywords, dates, location, language—and the API returns a structured list of articles.

The "Joy" of Integration

For a developer, the feeling of switching from scraping to a News API is pure relief. The friction disappears.

No more IP bans: The API handles the connections.
No more parsing HTML: You get clean data fields like title, body, published_at, and sentiment.
No more language barriers: The system supports 60 languages, meaning you don't need to write separate parsers for Arabic, Mandarin, or Spanish sites.

The result is that you can implement a feature in an afternoon that would have previously taken months of engineering time.

Deep Dive: Features That Replace Manual Work

It's not just about getting the text of an article. To truly replace a sophisticated internal scraping operation, an API needs to provide metadata and intelligence. Here is what you get out of the box, which you would otherwise have to build yourself.

1. Advanced Filtering and Search

When you are dealing with 500,000 sources, noise is a problem. You don't want all the news; you want the right news. APITube offers over 65 filters. You can drill down by:

Location: Search news specific to a country or region.
Sentiment: Filter for only positive or negative stories (crucial for brand reputation management).
Source Rank: Prioritize high-authority publications over obscure blogs.

2. Built-in NLP and AI

If you scrape a site yourself, you just get text. You then have to feed that text into a separate Natural Language Processing (NLP) engine to understand it.

APITube integrates this step. The API provides Sentiment Analysis and Topic Modeling directly in the response. This means the data arrives pre-analyzed. You know immediately if an article is critical of a specific stock or supportive of a political policy, without running your own expensive ML models.

3. Historical Data Access

Sometimes the goal isn't just monitoring today, but analyzing the past. Building a historical archive of the web is incredibly expensive in terms of storage. APITube provides access to 10 years of historical data. This allows financial analysts to backtest trading strategies against past news events without needing to store petabytes of data themselves.

The Result: Accelerating Innovation

So, what is the outcome of switching to a dedicated News API?

For the developers and businesses we've observed, the result is a dramatic increase in velocity. Instead of spending 80% of their time on data acquisition and 20% on analysis, they flip the ratio. They spend 100% of their time building value for their users.

Success Indicators:

Speed to Market: New features involving news feeds can launch in days.
Reliability: The data stream doesn't break when a publisher updates their website theme.
Scalability: You can go from tracking 100 topics to 10,000 topics instantly without adding more servers.

The feedback from users is generally one of satisfaction—specifically, the satisfaction of things "just working." The technical complexity is abstracted away, leaving a clean interface for innovation.

Use Cases: Who Needs 500,000 Sources?

You might be wondering if you really need access to half a million sources. The answer depends on your industry, but for many, breadth is just as important as depth.

Financial Analysis and Algo-Trading

Markets move on information. If a factory shuts down in Vietnam or a strike begins in Germany, that information hits local news sources first. By monitoring global feeds in real-time, financial algorithms can detect risks and opportunities hours before they appear in mainstream Western media.

Media Monitoring and PR

For Public Relations professionals, missing a negative story can be a disaster. A comprehensive API allows agencies to track brand mentions across the entire web—not just major outlets, but niche blogs and regional papers—to manage reputation effectively.

AI and LLM Training

Large Language Models (LLMs) are hungry for data. To train a model to understand current events or specific industry jargon, you need a massive, diverse stream of high-quality text. This API serves as a firehose of fresh content to keep models up to date.

Getting Started: A Recommendation

If you are looking to integrate news data, the recommendation is simple: Don't build it yourself.

The complexity of the modern web makes manual aggregation a losing battle. The smart move is to leverage specialized infrastructure.

Simple Integration Steps

Get an API Key: Sign up at APITube to get your credentials.
Choose Your Language: Whether you use Python, Java, JavaScript, PHP, or Go, there is an SDK or library ready for you.
Make Your First Request: Use the documentation to construct a query. Start simple, perhaps searching for a specific company name or industry keyword.
Refine: Use the filters to narrow down by language or sentiment.

Frequently Asked Questions

Is it legal to use news data from an API?

APITube collects and compiles publicly accessible web pages. It provides metadata, summaries, and links to the original content. It does not claim copyright over the articles. It acts as a search and indexing engine, similar to how Google indexes the web.

How fresh is the data?

The system is designed for real-time applications. With continuous crawling of 500,000+ sources, new articles appear in the API feed shortly after they are published on the source websites.

Can I try it for free?

Yes. There is a free plan available that resets credits daily. This allows you to test the integration, check the data quality, and see if it fits your specific use case before committing to a paid subscription.

What happens if I need more data than the plan allows?

The API operates on a credit system. If you scale up and need more requests, you can easily upgrade your plan. However, even on the free plan, the daily reset ensures you can keep developing and testing without interruption.

Does it support non-Latin scripts?

Absolutely. The API supports UTF-8 and handles 60 languages, including those with non-Latin scripts like Chinese, Japanese, Arabic, and Cyrillic. This is essential for truly global monitoring.

Summary

The goal of accessing the world's news data is no longer a technical impossibility for small teams. The difficulties of web scraping—the blocks, the bans, and the broken scripts—are problems of the past.

By using APITube, you achieve the result of having a global, real-time, and intelligent news feed integrated directly into your application. The satisfaction comes from reliability and the freedom to focus on what matters: your product's unique value.

If you are ready to stop fixing scrapers and start analyzing data, we recommend exploring the APITube documentation today.