Company Research

Step 1: POST /api/workflow_manager/start/         → returns report_id
Step 2: GET  /api/assets/get_notebook_status/     → poll until status = "Completed"
Step 3: POST /api/assets/download_report/         → retrieve JSON / PDF / DOCX / PPT

import time

def wait_for_report(report_id, api_key, poll_interval=15, timeout=600):
    headers = {"Authorization": f"Bearer {api_key}"}
    elapsed = 0
    while elapsed < timeout:
        r = requests.get(
            "https://api.wokelo.ai/api/assets/get_notebook_status/",
            headers=headers,
            params={"report_id": report_id}
        )
        status = r.json().get("status", "")
        print(f"[{elapsed}s] Status: {status}")
        if status == "Completed":
            return True
        if status == "Failed":
            raise Exception(f"Report {report_id} failed")
        time.sleep(poll_interval)
        elapsed += poll_interval
    raise TimeoutError(f"Report {report_id} did not complete within {timeout}s")

wait_for_report(report_id, api_key="<YOUR_API_TOKEN>")

# Fetch as JSON for programmatic processing
result = requests.post(
    "https://api.wokelo.ai/api/assets/download_report/",
    headers={"Authorization": "Bearer <YOUR_API_TOKEN>"},
    json={"report_id": report_id, "file_type": "json"}
)
report = result.json()

# Or download as a formatted document
pdf_result = requests.post(
    "https://api.wokelo.ai/api/assets/download_report/",
    headers={"Authorization": "Bearer <YOUR_API_TOKEN>"},
    json={"report_id": report_id, "file_type": "pdf"}
)
with open("company_research.pdf", "wb") as f:
    f.write(pdf_result.content)

Authorization: Bearer <YOUR_API_TOKEN>

POST https://api.wokelo.ai/api/workflow_manager/start/

{
  "report_id": 123345
}

{
  "report_id": 123345
}

response = requests.post(
    "https://api.wokelo.ai/api/workflow_manager/start/",
    headers=HEADERS,
    json={
        "workflow": "company_primer",
        "website": "https://www.stripe.com"
    }
)
report_id = response.json()["report_id"]

# Search for the company
search = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/search",
    headers=HEADERS,
    params={"query": "HubSpot", "search_by": "name", "company_type": "all"}
)
permalink = search.json()["data"][0]["permalink"]  # e.g. "hubspot"

# Submit research report
submit = requests.post(
    "https://api.wokelo.ai/api/workflow_manager/start/",
    headers=HEADERS,
    json={"workflow": "company_primer", "permalink": permalink}
)
report_id = submit.json()["report_id"]
print(f"Research for {permalink} started. report_id: {report_id}")

import requests, time, concurrent.futures

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

COMPANIES = ["salesforce", "hubspot", "pipedrive", "zoho", "freshworks"]

def submit_research(permalink):
    r = requests.post(
        "https://api.wokelo.ai/api/workflow_manager/start/",
        headers=HEADERS,
        json={"workflow": "company_primer", "permalink": permalink}
    )
    return permalink, r.json()["report_id"]

def poll_until_done(report_id, interval=20, timeout=900):
    elapsed = 0
    while elapsed < timeout:
        r = requests.get(
            "https://api.wokelo.ai/api/assets/get_notebook_status/",
            headers=HEADERS,
            params={"report_id": report_id}
        )
        status = r.json().get("status")
        if status == "Completed":
            return True
        if status == "Failed":
            return False
        time.sleep(interval)
        elapsed += interval
    return False

def fetch_report(report_id):
    r = requests.post(
        "https://api.wokelo.ai/api/assets/download_report/",
        headers=HEADERS,
        json={"report_id": report_id, "file_type": "json"}
    )
    return r.json()

# Submit all concurrently
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as pool:
    futures = {pool.submit(submit_research, c): c for c in COMPANIES}
    jobs = {}
    for future in concurrent.futures.as_completed(futures):
        permalink, report_id = future.result()
        jobs[permalink] = report_id
        print(f"Submitted: {permalink} → report_id {report_id}")

# Poll and collect
reports = {}
for permalink, report_id in jobs.items():
    ok = poll_until_done(report_id)
    if ok:
        reports[permalink] = fetch_report(report_id)
        print(f"Collected: {permalink}")
    else:
        print(f"Failed or timed out: {permalink}")

print(f"\nCollected {len(reports)} / {len(COMPANIES)} reports")

import requests

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

# Step 1: Upload the file
with open("target_company_cim.pdf", "rb") as f:
    upload_r = requests.post(
        "https://api.wokelo.ai/api/assets/upload/",
        headers=HEADERS,
        files={"files": ("target_company_cim.pdf", f, "application/pdf")}
    )
file_name = upload_r.json()["fileName"]  # unique file identifier

# Step 2: Submit report referencing the uploaded file
submit_r = requests.post(
    "https://api.wokelo.ai/api/workflow_manager/start/",
    headers={**HEADERS, "Content-Type": "application/json"},
    json={
        "workflow":     "company_primer",
        "permalink":    "target-company-permalink",
        "custom_files": [{"fileName": file_name}]
    }
)
report_id = submit_r.json()["report_id"]
print(f"Report with custom file submitted. report_id: {report_id}")

# Assume report is already downloaded as a dict
report = fetch_report(report_id)

# --- Quick Snapshot ---
snapshot   = report["Quick Snapshot"]["Quick Snapshot"]["quick_snapshot"]
firmograph  = snapshot["company_firmographics"]["details"]
financials  = firmograph["financials"]

print(f"Company:    {snapshot['company_firmographics']['organization']['name']}")
print(f"HQ:         {firmograph['hq']}")
print(f"Employees:  {firmograph['employees_in_linkedin']:,}")
print(f"Revenue:    ${financials['revenue']['value'] / 1e9:.1f}B ({financials['revenue']['period']})")
print(f"Market Cap: ${financials['market_cap']['value'] / 1e9:.1f}B")

# --- Key Insights (headlines only) ---
insights = report["Executive Summary"]["Key Insights"]["key_insights"]
print(f"\nKey Insights ({len(insights)} total):")
for i, card in enumerate(insights, 1):
    print(f"  {i}. {card['insight']['title']}")

# --- Recent M&A (2024+) ---
timeline = report["Transaction highlights"]["M&A Strategy"]["acquisitions"]["m_and_a_timeline"]
recent_ma = [t for t in timeline if int(t["acquisition_date"][:4]) >= 2024]
print(f"\nAcquisitions since 2024: {len(recent_ma)}")
for t in recent_ma:
    amt = t["acquisition_amount"]
    amt_str = f"${amt / 1e9:.1f}B" if isinstance(amt, float) and amt > 0 else "undisclosed"
    print(f"  {t['acquisition_date'][:10]}  {t['company']['organization']['name']}  ({amt_str})")

# --- Product areas ---
products = report["Product insights"]["Product and services"]["products_and_services"]
print(f"\nProduct areas ({len(products)}):")
for area in products:
    titles = [p["title"] for p in area["details"]]
    print(f"  {area['product_area']}: {', '.join(titles)}")

import requests

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

ppt_r = requests.post(
    "https://api.wokelo.ai/api/assets/download_report/",
    headers=HEADERS,
    json={"report_id": 123345, "file_type": "ppt"}
)

with open("salesforce_research.pptx", "wb") as f:
    f.write(ppt_r.content)

print("Saved salesforce_research.pptx")

status_r = requests.get(
    "https://api.wokelo.ai/api/assets/get_notebook_status/",
    headers=HEADERS,
    params={"report_id": report_id}
)
data = status_r.json()

if data.get("status") == "Failed":
    print(f"Report {report_id} failed.")
    # Resubmit with the same parameters
    resubmit = requests.post(
        "https://api.wokelo.ai/api/workflow_manager/start/",
        headers=HEADERS,
        json={"workflow": "company_primer", "permalink": "salesforce"}
    )
    new_report_id = resubmit.json()["report_id"]
    print(f"Resubmitted. New report_id: {new_report_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/workflow_manager/start/",
                headers=headers,
                json=body,
                timeout=30
            )
            if r.status_code == 429:
                time.sleep(2 ** attempt)
                continue
            r.raise_for_status()
            return r.json()["report_id"]
        except requests.exceptions.Timeout:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    raise Exception(f"Submission failed after {max_retries} attempts")

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

# Recommended polling pattern
for wait in [15, 15, 30, 30, 60, 60, 120]:   # seconds
    time.sleep(wait)
    status = get_status(report_id)
    if status in ("Completed", "Failed"):
        break

json={
    "workflow":   "company_primer",
    "permalink":  "some-niche-startup",
    "industry":   "Climate Technology & Carbon Markets"
}

# ❌ Will throw TypeError when amount is ""
formatted = f"${deal['acquisition_amount'] / 1e9:.1f}B"

# ✅ Safe — check type first
amt = deal.get("acquisition_amount")
formatted = f"${amt / 1e9:.1f}B" if isinstance(amt, (int, float)) and amt > 0 else "Undisclosed"