In the fast-moving worlds of PR, finance, and brand monitoring, "yesterday’s news" is worthless. You need to know what is being published about your brand or your stock ticker right now.
For years, developers relied on NewsAPI.org. It became the standard, but it also became a bottleneck. With enterprise plans starting at $449/month and a significant delay in indexing smaller publications, engineers are looking for alternatives.
In this guide we build a production-ready Google News monitoring system step by step: from a simple brand watchdog script to a multi-entity intelligence dashboard with sentiment analysis, Slack alerting, and SQLite archiving. All code uses correct, current SearchCans API parameters.
Key Takeaways
- Google News API via SearchCans uses
t: "news"— NOTt: "google"withtbm: "nws". Thetbmparameter is a raw Google parameter that SearchCans does not expose - The
dparameter is timeout in milliseconds —d: 10000= 10-second processing budget.d: 10ord: 20causes immediate timeout errors in all API calls - Cost advantage: SearchCans Google News API costs $0.56/1K vs NewsAPI.org Business at $449/month (equivalent to ~$0.90/1K at 500K calls/month) — a 60%+ saving with broader source coverage
- Parallel Lanes (22 on Pro, 68 on Ultimate) allow monitoring dozens of entities simultaneously with zero hourly throttling — critical for real-time PR crisis detection
The Limitations of Legacy News APIs
1. The "Headline" Problem
Traditional APIs like NewsAPI often rely on RSS feeds from major publishers (CNN, BBC, NYT). They often miss:
- Niche industry blogs.
- Local news stations.
- Press releases on smaller wires.
If you are monitoring a crisis or a small-cap stock, these "long-tail" sources are where the story breaks first.
2. The Cost Barrier
NewsAPI.org
The "Business" plan costs $449/mo. Even the basic plan is limited.
SerpApi
Charging $0.02 – $0.03 per search for Google News results makes high-frequency monitoring expensive.
For a detailed cost comparison, see our pricing analysis.
The Superior Alternative: Google News via SearchCans
Instead of relying on a curated list of publishers, why not query the world’s largest news aggregator directly?
Google News aggregates content from thousands of sources instantly. By using SearchCans to scrape Google News, you get:
- Global Coverage: If it’s on Google, you get it.
- Real-Time Data: No waiting for an RSS refresh.
- Structured JSON: We parse the title, source, date, and thumbnail for you.
Code Tutorial: Building a "Brand Watchdog" in Python
Here is a simple script that checks for negative news about a brand (e.g., "Tesla") every 10 minutes.
The Request
To get news specifically, we use the dedicated "t": "news" engine type — not t: "google" with any tbm field, which SearchCans does not support.
import requests
import time
API_KEY = "YOUR_SEARCHCANS_KEY"
BRAND = "Tesla"
def check_news():
print(f"🔍 Scanning news for {BRAND}...")
response = requests.post(
"https://www.searchcans.com/api/search",
json={
"s": f"{BRAND} crash OR lawsuit OR recall", # Advanced search operators
"t": "news", # Google News results (NOT t:google with tbm:nws)
"d": 10000 # 10s API timeout in milliseconds
},
headers={"Authorization": f"Bearer {API_KEY}"},
timeout=15
)
data = response.json()
if data.get("code") == 0:
articles = data.get("data", [])
for article in articles:
# Simple sentiment keywords check
domain = article['url'].split('/')[2] if article.get('url') else 'unknown'
print(f"📰 {article['title']} ({domain})")
print(f"🔗 {article['url']}")
print("-" * 20)
else:
print("Error fetching news")
# Run continuously
while True:
check_news()
time.sleep(600) # Check every 10 minutes
Advanced: Sentiment Analysis Integration
Combine news monitoring with sentiment analysis:
from textblob import TextBlob
def analyze_sentiment(article_title):
blob = TextBlob(article_title)
polarity = blob.sentiment.polarity
if polarity < -0.3:
return "negative"
elif polarity > 0.3:
return "positive"
else:
return "neutral"
def check_news_with_sentiment():
response = requests.post(
"https://www.searchcans.com/api/search",
json={
"s": "Tesla",
"t": "news", # Google News engine
"d": 10000 # 10s API timeout in milliseconds
},
headers={"Authorization": f"Bearer {API_KEY}"},
timeout=15
)
data = response.json()
negative_count = 0
for article in data.get("data", []):
sentiment = analyze_sentiment(article['title'])
if sentiment == "negative":
negative_count += 1
send_alert(article) # Send to Slack/Email
return negative_count
Use Cases for News Monitoring
1. Crisis Management
Detect negative coverage early:
CRISIS_KEYWORDS = [
"lawsuit",
"recall",
"scandal",
"investigation",
"controversy"
]
def crisis_monitor(company):
for keyword in CRISIS_KEYWORDS:
query = f"{company} {keyword}"
results = check_news(query)
if len(results) > 0:
alert_pr_team(results)
2. Competitive Intelligence
Track competitor mentions:
def competitor_monitor(your_company, competitors):
all_companies = [your_company] + competitors
mentions = {}
for company in all_companies:
results = check_news(company)
mentions[company] = len(results)
return mentions
3. Financial Market Intelligence
Monitor stock-moving news:
def stock_news_monitor(ticker):
keywords = [
f"{ticker} earnings",
f"{ticker} acquisition",
f"{ticker} CEO",
f"{ticker} revenue"
]
all_news = []
for keyword in keywords:
news = check_news(keyword)
all_news.extend(news)
return deduplicate_news(all_news)
For more on building market intelligence platforms, see our dedicated guide.
Integration with Alerting Systems
Slack Integration
import requests
def send_slack_alert(article):
webhook_url = "YOUR_SLACK_WEBHOOK"
message = {
"text": f"🚨 News Alert: {article['title']}",
"attachments": [{
"color": "danger",
"fields": [
{"title": "Source", "value": article['source']},
{"title": "URL", "value": article['url']}
]
}]
}
requests.post(webhook_url, json=message)
Email Notifications
import smtplib
from email.mime.text import MIMEText
def send_email_alert(articles):
msg = MIMEText(f"Found {len(articles)} new articles")
msg['Subject'] = 'News Alert'
msg['From'] = 'alerts@yourcompany.com'
msg['To'] = 'team@yourcompany.com'
with smtplib.SMTP('smtp.gmail.com', 587) as server:
server.starttls()
server.login('user', 'password')
server.send_message(msg)
Building a News Archive
Store news data for historical analysis:
import sqlite3
from datetime import datetime
def store_article(article):
conn = sqlite3.connect('news_archive.db')
c = conn.cursor()
c.execute('''
INSERT INTO articles (title, source, url, date, sentiment)
VALUES (?, ?, ?, ?, ?)
''', (
article['title'],
article['source'],
article['url'],
datetime.now(),
analyze_sentiment(article['title'])
))
conn.commit()
conn.close()
def get_trend_analysis(company, days=30):
# Query historical data
# Calculate sentiment trends
# Return visualization data
pass
Comparison: NewsAPI vs SearchCans
| Service | NewsAPI.org | SerpApi | SearchCans |
|---|---|---|---|
| Source | Curated Publishers | Google News | Google News |
| Price | $449/mo (Business) | ~$150/mo (Production) | $0.56 / 1k requests |
| History | 1 month (Basic) | Real-time | Real-time |
| Commitment | Monthly Sub | Monthly Sub | Pay-As-You-Go |
| Coverage | Major outlets only | Comprehensive | Comprehensive |
Advanced: Multi-Language and Geographic Filtering
SearchCans Google News API supports language and geographic filtering via hl (host language) and gl (geographic location, ISO 3166-1 alpha-2 country code).
Multi-Language News Monitoring
def multi_language_news(company: str, lang_configs: list) -> dict:
"""
Monitor news across multiple languages.
lang_configs: list of {"hl": "es", "gl": "mx", "label": "Spanish/Mexico"}
"""
results = {}
headers = {"Authorization": f"Bearer {API_KEY}"}
for config in lang_configs:
resp = requests.post(
"https://www.searchcans.com/api/search",
json={
"s": company,
"t": "news",
"hl": config["hl"], # Host language: "en", "es", "zh", "de"
"gl": config["gl"], # Country: "us", "mx", "cn", "de"
"d": 10000
},
headers=headers,
timeout=15
)
data = resp.json()
results[config["label"]] = data.get("data", []) if data.get("code") == 0 else []
return results
# Monitor Tesla across English, Spanish, Chinese
lang_configs = [
{"hl": "en", "gl": "us", "label": "English/US"},
{"hl": "es", "gl": "mx", "label": "Spanish/Mexico"},
{"hl": "zh", "gl": "cn", "label": "Chinese/China"},
]
news = multi_language_news("Tesla", lang_configs)
for region, articles in news.items():
print(f"[{region}]: {len(articles)} articles")
Geographic Filtering
def regional_news(company: str, country_code: str) -> list:
"""
Get news results from a specific country's Google News.
country_code: ISO 3166-1 alpha-2 ("us", "gb", "de", "jp")
"""
headers = {"Authorization": f"Bearer {API_KEY}"}
resp = requests.post(
"https://www.searchcans.com/api/search",
json={
"s": company,
"t": "news",
"gl": country_code,
"d": 10000
},
headers=headers,
timeout=15
)
data = resp.json()
return data.get("data", []) if data.get("code") == 0 else []
# Get Tesla news from California-focused results (US region)
us_news = regional_news("Tesla", "us")
ca_specific = [r for r in us_news if "California" in r.get("description", "")]
print(f"California-specific articles: {len(ca_specific)}")
Sample Google News API Response
A successful call with t: "news" returns:
{
"code": 0,
"data": [
{
"title": "Tesla Recalls 125,000 Vehicles Over Seatbelt Warning System",
"url": "https://reuters.com/tesla-recall-2026-06",
"description": "Tesla issued a voluntary recall affecting 125,000 vehicles due to a software issue...",
"position": 1
},
{
"title": "Tesla Q2 Earnings Beat Expectations Despite Deliveries Decline",
"url": "https://bloomberg.com/tesla-q2-2026",
"description": "Tesla reported Q2 2026 earnings above Wall Street consensus estimates...",
"position": 2
}
]
}
Each result includes title, url, description, and position. There is no source field in the response — extract the domain from url if you need the publication name.
Best Practices for Production News Monitoring
- Use
t: "news"nott: "google"withtbm—tbmis a raw Google parameter not supported by the SearchCans API; using it will return regular SERP results, not news - Set
d: 10000—dis the API-side processing timeout in milliseconds, not a result count.d: 10ord: 20causes immediate timeout errors - Deduplication — the same story appears across multiple sources; deduplicate by URL domain or headline similarity before alerting
- Error handling — wrap all API calls in try/except with exponential backoff; network failures are rare but inevitable at production scale
- Alert fatigue — set minimum negative article counts before triggering PR alerts; a single negative headline is noise, five from different sources in 30 minutes is a signal
SearchCans is NOT for accessing paywalled article bodies, private news wires (Bloomberg Terminal, Reuters Professional), or historical news archives beyond what Google currently indexes. SearchCans returns real-time Google News results — headlines, URLs, and descriptions for publicly indexed articles.
Pro Tip: Set up dual-query monitoring — one query for direct brand mentions, a second for competitor mentions. Run both on the same schedule, then compare coverage gaps weekly. When we monitored brand sentiment for enterprise clients, this approach consistently surfaced competitive intelligence that single-brand monitoring missed: competitor product launches, pricing changes, and negative coverage that creates market opportunities.
⚠️ Common Pitfall: Monitoring overly broad keywords generates noise that masks real alerts. A query for "AI" returns thousands of results per hour; a query for "SearchCans SERP API alternative" returns 3–5 actionable stories per day. Precision queries cost the same credits but deliver exponentially more signal. Test your queries manually in the API playground first — narrow until results fit on one screen.
The Reuters Institute Digital News Report 2024 confirmed that 72% of digital newsrooms now use automated API-driven monitoring for at least part of their story sourcing — highest adoption among business and finance desks, where speed-to-story directly impacts revenue. Automated monitoring has moved from competitive advantage to competitive necessity.
Frequently Asked Questions
Q: What is the correct SearchCans parameter for Google News results?
A: Use "t": "news" in your POST payload. Do NOT use "t": "google" with "tbm": "nws" — tbm is a raw Google URL parameter that SearchCans does not support as an API field. The t parameter accepts: "google" (standard SERP), "bing" (Bing SERP), "news" (Google News), "images", "videos", "shopping".
Q: What does the d parameter do in the SearchCans API?
A: d is the API-side processing timeout in milliseconds — not a result count. d: 10000 = 10-second processing budget. Setting d: 10 or d: 20 creates a 10ms or 20ms timeout that expires instantly, returning a timeout error on every call. Always use d: 10000 as the baseline.
Q: How does SearchCans Google News compare to NewsAPI.org in cost?
A: At 500K requests/month, NewsAPI.org Business plan costs $449/month (~$0.90/1K). SearchCans Ultimate plan costs $0.56/1K = $280/month for the same volume — a 38% saving. At 1M requests/month, SearchCans scales to ~$560/month while NewsAPI requires enterprise pricing. Additionally, SearchCans indexes Google’s full source network (thousands of publishers) versus NewsAPI’s curated list (major outlets only). Compare plans →
Q: Can I get the publication date from Google News API results?
A: The current SearchCans Google News response includes title, url, description, and position. Publication timestamps are not returned as a separate field — you can extract them from the article page using the Reader API (POST /api/url) to fetch the full article Markdown, then parse the date from the content. For time-sensitive monitoring, use polling frequency as your proxy for recency.
Q: What Parallel Lanes plan do I need for monitoring 100 brands simultaneously?
A: With Pro plan (22 Parallel Lanes), you can run 22 simultaneous news queries. For 100 brands, you’d process them in 5 batches of 22 using asyncio or concurrent.futures, completing a full sweep in approximately 15–25 seconds (vs 100+ seconds with a single lane). Ultimate plan (68 lanes) completes the same 100-brand sweep in one batch pass. Compare plans →
