Newsfeed

response = requests.post(
    "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
    headers={"Authorization": "Bearer <YOUR_API_TOKEN>"},
    json={
        "industry": ["Financial Services & Fintech"],
        "category": ["Mergers & Acquisitions", "Equity Fund-Raising"],
        "geo": ["USA", "GBR"],
        "sentiment": "positive",
        "published_date_after": "2026-04-01",
        "published_date_before": "2026-04-30",
        "limit": 50
    }
)
articles = response.json()["data"]

for article in articles:
    geo_str = ", ".join(article.get("geo", []))
    print(f"[{article['sentiment']}] [{article['newsworthiness_impact']}] {article['title']}")
    print(f"  {geo_str} | {article['published_date'][:10]}")
    print(f"  {article['ai_summary'][:150]}...")
    print()

Authorization: Bearer <YOUR_API_TOKEN>

POST https://api.wokelo.ai/api/enterprise/newsfeed/news/

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

{
  "status": "success",
  "data": [
    {
      "id": 10654876,
      "url": "https://www.globalbankingandfinance.com/kone-buy-rival-tk-elevator-34-4-billion-deal/",
      "title": "Kone to Acquire TK Elevator in Historic $34.4 Billion Finance Deal",
      "ai_summary": "Finnish elevator manufacturer Kone has agreed to acquire German rival TK Elevator (TKE) in a €29.4 billion ($34.4 billion) deal. The merger is expected to create the world's largest lift manufacturer with over €700 million in annual synergies and more than 100,000 employees.",
      "published_date": "2026-04-29 05:42:53",
      "source": "Wokelo",
      "geo": ["FIN", "DEU"],
      "sentiment": "Positive",
      "newsworthiness_impact": "High"
    },
    {
      "id": 10451190,
      "url": "https://techcrunch.com/2026/04/27/meta-inks-deal-for-solar-power-at-night-beamed-from-space/",
      "title": "Meta inks deal for solar power at night, beamed from space",
      "ai_summary": "Meta signed an agreement with Overview Energy to receive power from satellites transmitting infrared light to terrestrial solar farms. Overview plans to launch a fleet of 1,000 spacecraft by 2030 to beam space-generated power to Earth.",
      "published_date": "2026-04-27 10:00:00",
      "source": "Wokelo",
      "geo": ["USA"],
      "sentiment": "Positive",
      "newsworthiness_impact": "High"
    }
  ],
  "count": 12,
  "total": 12,
  "limit": 100,
  "offset": 0
}

import requests
from datetime import datetime, timedelta

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

PORTFOLIO_SECTORS = [
    "Financial Services & Fintech",
    "Enterprise Software & Cloud",
    "Healthcare & Life Sciences",
    "Industrials & Manufacturing"
]

ADVERSE_CATEGORIES = [
    "Legal Proceedings & Litigation",
    "Regulatory & Compliance",
    "Workforce Reductions",
    "Financial Distress & Restructuring",
    "Cybersecurity Incidents",
    "C-Suite Appointments & Departures",
    "Reputational Damage"
]

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

response = requests.post(
    "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
    headers=HEADERS,
    json={
        "industry":             PORTFOLIO_SECTORS,
        "category":             ADVERSE_CATEGORIES,
        "sentiment":            "negative",
        "published_date_after": start_date,
        "published_date_before": end_date,
        "limit":                200,
        "blacklisted": [
            "https://www.prnewswire.com/",
            "https://www.businesswire.com/"
        ]
    }
)

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

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

print(f"Adverse Signal Monitor — {start_date} to {end_date}")
print(f"Total signals: {data['total']} | High-impact: {len(high_impact)}\n")

for a in sorted(high_impact, key=lambda x: x["published_date"], reverse=True):
    print(f"[HIGH] {a['title']}")
    print(f"  {', '.join(a.get('geo', []))} | {a['published_date'][:10]}")
    print(f"  {a['ai_summary'][:250]}...")
    print()

import requests

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

response = requests.post(
    "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
    headers=HEADERS,
    json={
        "industry": [
            "Financial Services & Fintech",
            "Healthcare & Life Sciences",
            "Data, AI & ML Infrastructure",
            "Enterprise Software & Cloud"
        ],
        "category": [
            "Mergers & Acquisitions",
            "Equity Fund-Raising",
            "Partnerships & Alliances",
            "IPOs & Follow-on Offerings"
        ],
        "sentiment":             "positive",
        "geo":                   ["USA", "GBR", "DEU", "IND", "SGP"],
        "published_date_after":  "2026-04-01",
        "published_date_before": "2026-04-30",
        "limit":                 200
    }
)

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

# Group by geography for regional breakdown
from collections import defaultdict
by_geo = defaultdict(list)
for a in articles:
    for country in a.get("geo", ["Unknown"]):
        by_geo[country].append(a)

print("Deal Flow Feed — April 2026\n")
for country, items in sorted(by_geo.items(), key=lambda x: -len(x[1])):
    print(f"{country}: {len(items)} articles")
    for a in items[:2]:
        print(f"  [{a['published_date'][:10]}] {a['title']}")
    print()

import requests
from collections import defaultdict

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

ALL_FUND_SECTORS = [
    "Financial Services & Fintech",
    "Healthcare & Life Sciences",
    "Enterprise Software & Cloud",
    "Data, AI & ML Infrastructure",
    "Energy, Utilities & Environment",
    "Industrials & Manufacturing"
]

response = requests.post(
    "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
    headers=HEADERS,
    json={
        "industry":              ALL_FUND_SECTORS,
        "published_date_after":  "2026-04-01",
        "published_date_before": "2026-04-30",
        "limit":                 1000
    }
)

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

# Keep only high-impact for LP brevity
high_impact = [a for a in articles if a.get("newsworthiness_impact") == "High"]

# Split by sentiment for narrative framing
positive = [a for a in high_impact if a.get("sentiment") == "Positive"]
negative = [a for a in high_impact if a.get("sentiment") == "Negative"]

print(f"April 2026 LP Digest")
print(f"Total articles indexed: {data['total']}")
print(f"High-impact: {len(high_impact)} ({len(positive)} positive, {len(negative)} negative)\n")

print("=== Positive Developments ===")
for a in sorted(positive, key=lambda x: x["published_date"], reverse=True)[:10]:
    print(f"  [{a['published_date'][:10]}] {a['title']}")
    print(f"    {a['ai_summary'][:150]}...")

print("\n=== Adverse Signals ===")
for a in sorted(negative, key=lambda x: x["published_date"], reverse=True)[:10]:
    print(f"  [{a['published_date'][:10]}] {a['title']}")
    print(f"    {a['ai_summary'][:150]}...")

import requests

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

BODY = {
    "industry": [
        "Healthcare & Life Sciences",
        "Data, AI & ML Infrastructure"
    ],
    "published_date_after":  "2026-01-01",
    "published_date_before": "2026-04-30",
    "limit":  100,
    "offset": 0
}

all_articles = []

while True:
    response = requests.post(
        "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
        headers=HEADERS,
        json=BODY
    )
    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

    BODY["offset"] += BODY["limit"]

# Deduplicate by id
seen = set()
unique = [a for a in all_articles if not (a["id"] in seen or seen.add(a["id"]))]
print(f"\nUnique articles: {len(unique)}")

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

async function getNewsfeed(options = {}) {
  const body = {
    ...(options.industry           && { industry:              options.industry }),
    ...(options.category           && { category:              options.category }),
    ...(options.sentiment          && { sentiment:             options.sentiment }),
    ...(options.geo                && { geo:                   options.geo }),
    ...(options.breakingNews       && { breaking_news:         options.breakingNews }),
    ...(options.publishedDateAfter && { published_date_after:  options.publishedDateAfter }),
    ...(options.publishedDateBefore && { published_date_before: options.publishedDateBefore }),
    ...(options.blacklisted        && { blacklisted:           options.blacklisted }),
    limit:  options.limit  || 100,
    offset: options.offset || 0
  };

  const response = await fetch(
    "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
    {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.WOKELO_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify(body)
    }
  );

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

  return response.json();
}

// Example: breaking fintech and AI news in the US today
getNewsfeed({
  industry:            ["Financial Services & Fintech", "Data, AI & ML Infrastructure"],
  breakingNews:        true,
  geo:                 ["USA"],
  sentiment:           "positive",
  publishedDateAfter:  "2026-05-13",
  publishedDateBefore: "2026-05-14"
}).then(data => {
  console.log(`Found ${data.total} articles`);
  data.data.forEach(a => {
    console.log(`[${a.newsworthiness_impact}] [${a.sentiment}] ${a.title}`);
  });
});

{
  "status": "error",
  "detail": "Invalid industry name: 'Fintech'. See /industry-names for accepted values."
}

import time, requests

def fetch_newsfeed_with_retry(body, api_key, max_retries=3):
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://api.wokelo.ai/api/enterprise/newsfeed/news/",
                headers=headers,
                json=body,
                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")

# ❌ Will fail — not an exact taxonomy match
body["industry"] = ["Fintech", "AI & Machine Learning"]

# ✅ Correct — exact taxonomy names
body["industry"] = ["Financial Services & Fintech", "Data, AI & ML Infrastructure"]

# Broad — all healthcare news
body = {"industry": ["Healthcare & Life Sciences"]}

# Precise — only M&A, fundraising, and product launches in healthcare
body = {
    "industry":  ["Healthcare & Life Sciences"],
    "category":  ["Mergers & Acquisitions", "Equity Fund-Raising", "Product Launches & Enhancements"]
}

# Opportunity feed — deal flow, launches, wins
positive_body = {**base_body, "sentiment": "positive"}

# Risk feed — adverse signals, distress, litigation
negative_body = {**base_body, "sentiment": "negative"}

from datetime import datetime, timedelta

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

body["published_date_after"]  = start_date
body["published_date_before"] = end_date

# ❌ Wrong format for Newsfeed API
body["blacklisted"] = "https://www.prnewswire.com/, https://www.businesswire.com/"

# ✅ Correct format — JSON array
body["blacklisted"] = [
    "https://www.prnewswire.com/",
    "https://www.businesswire.com/",
    "https://www.globenewswire.com/"
]

seen_ids = set()
new_only = [a for a in articles if not (a["id"] in seen_ids or seen_ids.add(a["id"]))]