Company Deep Intelligence

Step 1: POST /api/enterprise/company/enrich/        → returns request_id + status: "PENDING"
Step 2: GET  /api/enterprise/request/status/        → poll until status = "COMPLETED"; result embedded in response

import time, requests

def poll_until_complete(request_id, api_key, poll_interval=10, timeout=600):
    headers = {"Authorization": f"Bearer {api_key}"}
    elapsed = 0
    while elapsed < timeout:
        r = requests.get(
            "https://api.wokelo.ai/api/enterprise/request/status/",
            headers=headers,
            params={"request_id": request_id}
        )
        data = r.json()
        status = data.get("status", "")
        print(f"[{elapsed}s] Status: {status}")
        if status == "COMPLETED":
            return data["result"]      # result is embedded in the status response
        if status == "FAILED":
            raise Exception(f"Request {request_id} failed")
        time.sleep(poll_interval)
        elapsed += poll_interval
    raise TimeoutError(f"Request {request_id} did not complete within {timeout}s")

result = poll_until_complete(request_id, api_key="<YOUR_API_TOKEN>")
print(f"Companies enriched: {list(result.keys())}")

# Result is keyed by the company identifier you submitted
company_data = result["https://tesla.com"]   # or result["tesla"] if you used a permalink

firmographics = company_data["firmographics"]
print(f"Company: {firmographics['name']}")
print(f"Type: {firmographics['type']} | Status: {firmographics['operating_status']}")

enrichment = company_data["CP enrichment"]

# Products overview
if "products_and_services" in enrichment:
    overview = enrichment["products_and_services"]["product_overview"]["summary"]
    print(f"\nProducts overview:\n{overview[:400]}...")

# Recent launches
if "product_launches" in enrichment:
    launches = enrichment["product_launches"]["product_launches_and_initiatives"]["released_products"]
    print(f"\nRecent launches ({len(launches)}):")
    for launch in launches[:3]:
        print(f"  [{launch['date']}] {launch['initiative']}")

Authorization: Bearer <YOUR_API_TOKEN>

POST https://api.wokelo.ai/api/enterprise/company/enrich/

{
  "request_id": "c2ad9d34-f432-4b9b-b5a2-46fbd124db5f",
  "status": "PENDING"
}

{
  "request_id": "...",
  "status": "COMPLETED",
  "result": {
    "zendesk": {
      "firmographics": { ... },
      "CP enrichment": { ... },
      "meta": { ... }
    },
    "freshworks": {
      "firmographics": { ... },
      "CP enrichment": { ... },
      "meta": { ... }
    }
  }
}

{
  "products_and_services": {
    "product_overview": {
      "source": [ { "id": 1, "title": "...", "url": "...", "publisher": "", "date": "" } ],
      "summary": "<markdown narrative with source brackets>",
      "screenshot_url": "<URL to product homepage screenshot>"
    },
    "products_and_services": [
      {
        "product_area": "Customer Service AI Solutions",
        "details": [
          { "title": "AI Agents", "summary": "Autonomous bots that resolve..." }
        ],
        "sources": "1-3"
      }
    ]
  }
}

{
  "product_launches": {
    "product_launches_and_initiatives": {
      "released_products": [
        {
          "date": "26-Mar-2025",
          "initiative": "Resolution Platform",
          "sources": [
            { "url": "...", "title": "...", "publisher": "...", "publishedDate": "2025-03-26" }
          ],
          "summary": [
            "AI Integration: **AI-powered resolution** platform with autonomous agents.",
            "Outcome Focus: Designed to deliver **faster resolutions**."
          ]
        }
      ],
      "future_announcements": [
        {
          "date": "31-Aug-2027",
          "initiative": "Sell Discontinuation",
          "sources": [ { ... } ],
          "summary": [ "Product Exit: Shutting down **Zendesk Sell** on **Aug 31, 2027**." ]
        }
      ]
    }
  }
}

{
  "strategic_initiatives": {
    "strategic_moves": [
      {
        "Area": "Layoffs",
        "Details": [
          {
            "point": "**Freshworks laid off 13% of workforce** (660 employees)...",
            "sources": [ { "url": "...", "title": "...", "publisher": "...", "publishedDate": "..." } ]
          }
        ]
      },
      {
        "Area": "Office expansion",
        "Details": [ { "point": "...", "sources": [ ... ] } ]
      }
    ]
  }
}

{
  "request_id": "c2ad9d34-f432-4b9b-b5a2-46fbd124db5f",
  "status": "PENDING"
}

import requests, time
from collections import defaultdict

API_KEY = "<YOUR_API_TOKEN>"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

WATCHLIST = ["zendesk", "freshworks", "salesforce", "hubspot", "pipedrive"]

submit = requests.post(
    "https://api.wokelo.ai/api/enterprise/company/enrich/",
    headers=HEADERS,
    json={
        "companies": WATCHLIST,
        "sections":  ["strategic_initiatives"]
    }
)
request_id = submit.json()["request_id"]

# Poll
while True:
    r = requests.get(
        "https://api.wokelo.ai/api/enterprise/request/status/",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params={"request_id": request_id}
    )
    data = r.json()
    if data["status"] == "COMPLETED":
        result = data["result"]
        break
    if data["status"] == "FAILED":
        raise Exception("Request failed")
    time.sleep(10)

ADVERSE_AREAS = {"Layoffs", "Workforce Reductions", "Office Closures"}
GROWTH_AREAS  = {"Hiring", "Office expansion", "Awards and recognitions"}

print("=== Adverse Signals ===")
for company_key, company_data in result.items():
    name = company_data["firmographics"]["name"]
    moves = company_data["CP enrichment"].get("strategic_initiatives", {}).get("strategic_moves", [])
    for move in moves:
        if move["Area"] in ADVERSE_AREAS:
            print(f"\n[{name}] {move['Area']}")
            for detail in move["Details"][:2]:
                print(f"  • {detail['point'][:200]}...")

print("\n=== Growth Signals ===")
for company_key, company_data in result.items():
    name = company_data["firmographics"]["name"]
    moves = company_data["CP enrichment"].get("strategic_initiatives", {}).get("strategic_moves", [])
    for move in moves:
        if move["Area"] in GROWTH_AREAS:
            print(f"\n[{name}] {move['Area']}")
            for detail in move["Details"][:1]:
                print(f"  • {detail['point'][:200]}...")

from datetime import datetime

submit = requests.post(
    "https://api.wokelo.ai/api/enterprise/company/enrich/",
    headers=HEADERS,
    json={
        "companies": ["zendesk", "freshworks", "intercom"],
        "sections":  ["product_launches"]
    }
)
request_id = submit.json()["request_id"]

# Poll (abbreviated — use the poll helper from Quick Start)
result = poll_until_complete(request_id, API_KEY)

# Flatten all launches into a single timeline
all_launches = []
for company_key, company_data in result.items():
    name = company_data["firmographics"]["name"]
    launches = (
        company_data["CP enrichment"]
        .get("product_launches", {})
        .get("product_launches_and_initiatives", {})
        .get("released_products", [])
    )
    for launch in launches:
        all_launches.append({
            "company": name,
            "date":    launch["date"],
            "initiative": launch["initiative"],
            "bullets": launch["summary"]
        })

# Sort most recent first
def parse_date(d):
    try:
        return datetime.strptime(d, "%d-%b-%Y")
    except ValueError:
        return datetime.min

all_launches.sort(key=lambda x: parse_date(x["date"]), reverse=True)

print("Unified Product Launch Timeline\n" + "="*60)
for launch in all_launches[:20]:
    print(f"[{launch['date']}] {launch['company']} — {launch['initiative']}")
    for bullet in launch["bullets"][:1]:
        print(f"  • {bullet}")

submit = requests.post(
    "https://api.wokelo.ai/api/enterprise/company/enrich/",
    headers=HEADERS,
    json={
        "companies": ["https://www.airbase.com"],
        "sections":  ["management_profiles", "key_customers", "partnerships"]
    }
)
request_id = submit.json()["request_id"]
result = poll_until_complete(request_id, API_KEY)

company_data = result["https://www.airbase.com"]
enrichment   = company_data["CP enrichment"]

print(f"Target: {company_data['firmographics']['name']}")
print(f"Status: {company_data['firmographics']['operating_status']}\n")

if "management_profiles" in enrichment:
    print("=== Leadership ===")
    # Navigate section-specific structure
    for key, val in enrichment["management_profiles"].items():
        if isinstance(val, dict):
            print(str(val)[:500])

submit = requests.post(
    "https://api.wokelo.ai/api/enterprise/company/enrich/",
    headers=HEADERS,
    json={
        "companies": ["salesforce", "hubspot", "zendesk", "freshworks"],
        "sections":  ["employee_sentiment", "product_sentiment"]
    }
)
request_id = submit.json()["request_id"]
result = poll_until_complete(request_id, API_KEY)

for company_key, company_data in result.items():
    name       = company_data["firmographics"]["name"]
    enrichment = company_data["CP enrichment"]
    print(f"\n{name}")
    for section in ["employee_sentiment", "product_sentiment"]:
        if section in enrichment:
            # Navigate to summary — structure varies; iterate to find it
            for sub_key, sub_val in enrichment[section].items():
                if isinstance(sub_val, dict) and "summary" in sub_val:
                    print(f"  [{section}] {sub_val['summary'][:200]}...")

import requests, time, concurrent.futures

API_KEY  = "<YOUR_API_TOKEN>"
HEADERS  = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

WATCHLIST = [
    "salesforce", "hubspot", "pipedrive", "zoho", "freshworks",
    "zendesk", "intercom", "servicenow", "atlassian", "jira-software"
]

def submit_batch(companies, sections):
    r = requests.post(
        "https://api.wokelo.ai/api/enterprise/company/enrich/",
        headers=HEADERS,
        json={"companies": companies, "sections": sections}
    )
    return r.json()["request_id"]

def poll_until_done(request_id, interval=10, timeout=600):
    elapsed = 0
    while elapsed < timeout:
        r = requests.get(
            "https://api.wokelo.ai/api/enterprise/request/status/",
            headers={"Authorization": f"Bearer {API_KEY}"},
            params={"request_id": request_id}
        )
        data = r.json()
        if data["status"] == "COMPLETED":
            return data["result"]
        if data["status"] == "FAILED":
            return None
        time.sleep(interval)
        elapsed += interval
    return None

SECTIONS = ["products_and_services", "strategic_initiatives"]
BATCH_SIZE = 5

# Split into batches
batches = [WATCHLIST[i:i+BATCH_SIZE] for i in range(0, len(WATCHLIST), BATCH_SIZE)]

# Submit all batches concurrently
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
    futures = {pool.submit(submit_batch, batch, SECTIONS): batch for batch in batches}
    jobs = []
    for f in concurrent.futures.as_completed(futures):
        request_id = f.result()
        jobs.append(request_id)
        print(f"Submitted batch → {request_id}")

# Collect all results
all_results = {}
for request_id in jobs:
    result = poll_until_done(request_id)
    if result:
        all_results.update(result)
        print(f"Collected batch from {request_id}: {list(result.keys())}")

print(f"\nTotal companies enriched: {len(all_results)}")

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

async function enrichCompanies(companies, sections) {
  // Submit
  const submitRes = await fetch(
    "https://api.wokelo.ai/api/enterprise/company/enrich/",
    {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.WOKELO_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ companies, sections })
    }
  );
  const { request_id } = await submitRes.json();
  console.log(`Submitted. request_id: ${request_id}`);

  // Poll
  while (true) {
    await new Promise(r => setTimeout(r, 10000));
    const statusRes = await fetch(
      `https://api.wokelo.ai/api/enterprise/request/status/?request_id=${request_id}`,
      { headers: { "Authorization": `Bearer ${process.env.WOKELO_API_KEY}` } }
    );
    const data = await statusRes.json();
    console.log(`Status: ${data.status}`);
    if (data.status === "COMPLETED") return data.result;
    if (data.status === "FAILED")    throw new Error(`Request ${request_id} failed`);
  }
}

// Example: product intelligence on three CX platforms
enrichCompanies(
  ["zendesk", "freshworks", "intercom"],
  ["products_and_services", "product_launches"]
).then(result => {
  for (const [companyKey, data] of Object.entries(result)) {
    console.log(`\n${data.firmographics.name}`);
    const launches = data["CP enrichment"]
      ?.product_launches
      ?.product_launches_and_initiatives
      ?.released_products ?? [];
    console.log(`  Recent launches: ${launches.length}`);
    launches.slice(0, 2).forEach(l => console.log(`  [${l.date}] ${l.initiative}`));
  }
});

r = requests.get(
    "https://api.wokelo.ai/api/enterprise/request/status/",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={"request_id": request_id}
)
if r.json().get("status") == "FAILED":
    print(f"Request {request_id} failed. Resubmitting...")
    resubmit = requests.post(
        "https://api.wokelo.ai/api/enterprise/company/enrich/",
        headers=HEADERS,
        json={"companies": ["zendesk"], "sections": ["products_and_services"]}
    )
    print(f"New request_id: {resubmit.json()['request_id']}")

import time, requests

def submit_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:
            r = requests.post(
                "https://api.wokelo.ai/api/enterprise/company/enrich/",
                headers=headers, json=body, timeout=30
            )
            if r.status_code == 429:
                time.sleep(2 ** attempt)
                continue
            r.raise_for_status()
            return r.json()["request_id"]
        except requests.exceptions.Timeout:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    raise Exception(f"Submission failed after {max_retries} attempts")

# Fast pre-IC check — two sections
json={"companies": ["zendesk"], "sections": ["products_and_services", "product_launches"]}

# Full intelligence sweep — all nine sections, expect longer processing
json={"companies": ["zendesk"], "sections": [
    "products_and_services", "product_launches", "strategic_initiatives",
    "partnerships", "business_model", "key_customers",
    "management_profiles", "employee_sentiment", "product_sentiment"
]}

search = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/search",
    headers=HEADERS,
    params={"query": "Zendesk", "search_by": "name"}
)
permalink = search.json()["data"][0]["permalink"]   # "zendesk"

# ❌ Inefficient — five separate round-trips
for company in ["zendesk", "freshworks", "intercom", "servicenow", "atlassian"]:
    submit_request([company], sections)

# ✅ Efficient — one request, five companies processed in parallel
submit_request(["zendesk", "freshworks", "intercom", "servicenow", "atlassian"], sections)

# ❌ Mixed formats — inconsistent result keys
companies=["https://zendesk.com", "freshworks", "https://intercom.com"]

# ✅ Consistent — all permalinks, all result keys are permalinks
companies=["zendesk", "freshworks", "intercom"]

sources = product_area.get("sources", "")

# products_and_services — string range
if isinstance(sources, str):
    print(f"Source IDs: {sources}")   # e.g. "1-3"

# product_launches / strategic_initiatives — array of citation objects
elif isinstance(sources, list):
    for cite in sources:
        print(f"  {cite['title']} ({cite['publishedDate']})")

# ❌ TypeError — summary is a list, not a string
print(launch["summary"][:200])

# ✅ Correct
for bullet in launch["summary"]:
    print(f"  • {bullet}")

# ❌ Wrong endpoint for this API
requests.get(".../api/assets/get_notebook_status/", params={"report_id": request_id})

# ✅ Correct endpoint for Company Deep Intelligence
requests.get(".../api/enterprise/request/status/", params={"request_id": request_id})