Company News Monitoring

response = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/news/",
    headers={"Authorization": "Bearer <YOUR_API_TOKEN>"},
    params={
        "company": "tesla",
        "category": "MERGERS & ACQUISITIONS, PARTNERSHIPS & ALLIANCES",
        "start_date": "2025-01-01",
        "end_date": "2026-03-31",
        "limit": 50
    }
)
articles = response.json()["data"]

for article in articles:
    print(f"[{article['primary_tag']}] {article['title']}")
    print(f"  {article['publisher']} | {article['published_date'][:10]} | {article.get('sentiment', 'N/A')}")
    print(f"  {article['ai_summary'][:120]}...")
    print()

Authorization: Bearer <YOUR_API_TOKEN>

GET https://api.wokelo.ai/api/enterprise/company/news/

{
  "status": "success",
  "data": [ ...article objects... ],
  "count": 4,
  "total": 4,
  "limit": 100,
  "offset": 0
}

{
  "status": "success",
  "data": [
    {
      "ai_summary": "Brex CEO Pedro Franceschi discusses the rapid $5.15 billion deal with Capital One, highlighting the deal's significance in the fintech space, Brex's evolving valuation, and plans for aggressive market competition.",
      "type": "Mergers & Acquisitions",
      "url": "https://www.youtube.com/watch?v=3a3omxYXqK4",
      "title": "How Brex signed a $5.15B Deal in ~40 Days",
      "company_name": "Brex",
      "publisher": "Youtube",
      "published_date": "2026-01-30 00:00:00",
      "source": "Wokelo",
      "author": "",
      "countries": [],
      "sentiment": "",
      "company_names": [],
      "primary_tag": "Mergers & Acquisitions",
      "original_language": "",
      "secondary_tags": [],
      "newsworthiness_impact": "",
      "scraped_text": "..."
    }
  ],
  "count": 12,
  "total": 12,
  "limit": 100,
  "offset": 0
}

import requests

HEADERS = {"Authorization": "Bearer <YOUR_API_TOKEN>"}

DD_CATEGORIES = ", ".join([
    "MERGERS & ACQUISITIONS",
    "LEGAL PROCEEDINGS & LITIGATION",
    "REGULATORY APPROVALS & CERTIFICATIONS",
    "FINANCIAL DISTRESS & RESTRUCTURING",
    "C-SUITE APPOINTMENTS & DEPARTURES",
    "EARNINGS RELEASES",
    "PARTNERSHIPS & ALLIANCES"
])

# Exclude wire services — focus on editorial coverage
BLACKLIST = ", ".join([
    "https://www.prnewswire.com/",
    "https://www.businesswire.com/",
    "https://www.globenewswire.com/"
])

response = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/news/",
    headers=HEADERS,
    params={
        "company": "tesla",
        "category": DD_CATEGORIES,
        "start_date": "2024-01-01",
        "end_date": "2026-03-31",
        "blacklisted": BLACKLIST,
        "limit": 200
    }
)

data = response.json()
articles = data["data"]

print(f"Retrieved {data['count']} articles (total matching: {data['total']})\n")

# Group by primary tag
from collections import defaultdict
by_category = defaultdict(list)
for a in articles:
    tag = a.get("primary_tag") or "Uncategorised"
    by_category[tag].append(a)

for category, items in sorted(by_category.items(), key=lambda x: -len(x[1])):
    print(f"\n{'='*60}")
    print(f"{category} ({len(items)} articles)")
    print('='*60)
    for a in items[:3]:  # Show top 3 per category
        print(f"  [{a['published_date'][:10]}] {a['title']}")
        print(f"  {a['ai_summary'][:150]}...")

import requests
from datetime import datetime, timedelta

HEADERS = {"Authorization": "Bearer <YOUR_API_TOKEN>"}

COMPETITORS = ["salesforce", "hubspot", "pipedrive", "zoho"]

end_date = datetime.today().strftime("%Y-%m-%d")
start_date = (datetime.today() - timedelta(days=90)).strftime("%Y-%m-%d")

INTEL_CATEGORIES = ", ".join([
    "PRODUCT LAUNCHES & ENHANCEMENTS",
    "PARTNERSHIPS & ALLIANCES",
    "GEOGRAPHIC EXPANSION",
    "MERGERS & ACQUISITIONS",
    "EQUITY FUND-RAISING"
])

all_articles = []

for company in COMPETITORS:
    response = requests.get(
        "https://api.wokelo.ai/api/enterprise/company/news/",
        headers=HEADERS,
        params={
            "company": company,
            "category": INTEL_CATEGORIES,
            "start_date": start_date,
            "end_date": end_date,
            "limit": 50
        }
    )
    articles = response.json().get("data", [])
    for a in articles:
        a["_queried_company"] = company
    all_articles.extend(articles)

# Sort all articles by date, most recent first
all_articles.sort(key=lambda x: x["published_date"], reverse=True)

print(f"\nCompetitive Intelligence Feed — {start_date} to {end_date}")
print(f"Total articles: {len(all_articles)}\n")

for a in all_articles[:20]:
    sentiment = a.get("sentiment") or "—"
    print(f"[{a['_queried_company'].upper()}] [{a['primary_tag']}] [{sentiment}]")
    print(f"  {a['title']}")
    print(f"  {a['publisher']} | {a['published_date'][:10]}")
    print()

import requests

HEADERS = {"Authorization": "Bearer <YOUR_API_TOKEN>"}
PARAMS = {
    "company": "apple",
    "start_date": "2024-01-01",
    "limit": 100,
    "offset": 0
}

all_articles = []

while True:
    response = requests.get(
        "https://api.wokelo.ai/api/enterprise/company/news/",
        headers=HEADERS,
        params=PARAMS
    )
    data = response.json()
    batch = data.get("data", [])
    all_articles.extend(batch)

    print(f"Fetched {len(all_articles)} / {data['total']} articles")

    if len(all_articles) >= data["total"] or not batch:
        break

    PARAMS["offset"] += PARAMS["limit"]

print(f"\nTotal retrieved: {len(all_articles)}")

import requests

HEADERS = {"Authorization": "Bearer <YOUR_API_TOKEN>"}

response = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/news/",
    headers=HEADERS,
    params={
        "company": "openai",
        "category": "MERGERS & ACQUISITIONS, EQUITY FUND-RAISING",
        "start_date": "2025-01-01",
        "limit": 20
    }
)

articles = response.json()["data"]

# Filter to articles with scraped text available
with_text = [a for a in articles if a.get("scraped_text", "").strip()]
print(f"{len(with_text)} of {len(articles)} articles have full text\n")

for a in with_text[:3]:
    word_count = len(a["scraped_text"].split())
    print(f"Title: {a['title']}")
    print(f"Publisher: {a['publisher']} | Words: {word_count}")
    print(f"AI Summary: {a['ai_summary']}")
    print()
    # Pass a["scraped_text"] to your LLM pipeline here

const fetch = require("node-fetch");

async function getCompanyNews(company, options = {}) {
  const params = new URLSearchParams({
    company,
    ...(options.startDate && { start_date: options.startDate }),
    ...(options.endDate   && { end_date:   options.endDate }),
    ...(options.category  && { category:   options.category }),
    limit:  options.limit  || 100,
    offset: options.offset || 0
  });

  const response = await fetch(
    `https://api.wokelo.ai/api/enterprise/company/news/?${params}`,
    {
      method: "GET",
      headers: {
        "Authorization": `Bearer ${process.env.WOKELO_API_KEY}`,
        "Content-Type": "application/json"
      }
    }
  );

  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${response.statusText}`);
  }

  return response.json();
}

// Example: get M&A news for Tesla in 2025
getCompanyNews("tesla", {
  category: "MERGERS & ACQUISITIONS, PARTNERSHIPS & ALLIANCES",
  startDate: "2025-01-01",
  endDate:   "2025-12-31"
}).then(data => {
  console.log(`Found ${data.total} articles`);
  data.data.forEach(a => {
    console.log(`[${a.primary_tag}] ${a.title} — ${a.publisher}`);
  });
});

{
  "status": "error",
  "detail": "Company permalink 'unknown-co' could not be resolved."
}

import time, requests

def fetch_news_with_retry(params, api_key, max_retries=3):
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    for attempt in range(max_retries):
        try:
            response = requests.get(
                "https://api.wokelo.ai/api/enterprise/company/news/",
                headers=headers,
                params=params,
                timeout=30
            )
            if response.status_code == 429:
                wait = 2 ** attempt   # 1s, 2s, 4s
                time.sleep(wait)
                continue
            response.raise_for_status()
            return response.json()
        except requests.exceptions.Timeout:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    raise Exception(f"Failed after {max_retries} attempts")

# Resolve permalink first
search = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/search/",
    headers=HEADERS,
    params={"query": "Tesla Inc"}
)
permalink = search.json()["results"][0]["permalink"]  # "tesla"

# For portfolio monitoring — adverse signals only
params["category"] = (
    "LEGAL PROCEEDINGS & LITIGATION, "
    "WORKFORCE REDUCTIONS, "
    "FINANCIAL DISTRESS & RESTRUCTURING, "
    "CYBERSECURITY INCIDENTS, "
    "C-SUITE APPOINTMENTS & DEPARTURES"
)

params["blacklisted"] = (
    "https://www.prnewswire.com/, "
    "https://www.businesswire.com/, "
    "https://www.globenewswire.com/"
)

high_signal = [a for a in articles if a.get("newsworthiness_impact") == "High"]

# ❌ KeyError risk when field is present but empty
if article["sentiment"] == "Negative":
    ...

# ✅ Safe
if article.get("sentiment") == "Negative":
    ...

content = article.get("scraped_text", "").strip()
if not content:
    content = article.get("ai_summary", "")