Peer Comparison

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, requests

def wait_for_report(report_id, api_key, poll_interval=20, timeout=900):
    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()
print(f"Sections: {list(report.keys())}")

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

Authorization: Bearer <YOUR_API_TOKEN>

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

{
  "report_id": 1002345
}

"Total revenue": {
  "period": "2024-12-31",
  "v": 139236000.0,
  "currency": "USD"
}

# Revenue in millions
revenue_m = financials["Total revenue"]["v"] / 1_000_000  # → 139.2

# EBITDA margin is stored as a fraction, not a percentage
ebitda_margin_pct = financials["EBITDA margin (%)"]["v"] * 100  # → 0.068%

{
  "report_id": 1002345
}

# Assume report is already downloaded as a dict
report = result.json()

companies = (
    report["Firmographics"]
    ["Firmographic"]
    ["firmographics"]
    ["firmographics"]
)

print(f"{'Company':<20} {'Type':<12} {'HQ':<30} {'Employees':<20} {'Total Funding'}")
print("-" * 100)

for co in companies:
    name    = co["organization"]["name"]
    details = co["details"]
    funding = details.get("total_funding", 0)
    fund_str = f"${funding / 1e9:.1f}B" if funding >= 1e9 else (f"${funding / 1e6:.0f}M" if funding > 0 else "—")

    print(
        f"{name:<20} "
        f"{details.get('company_type', '—'):<12} "
        f"{details.get('hq', '—'):<30} "
        f"{details.get('employees_in_crunchbase', '—'):<20} "
        f"{fund_str}"
    )

def safe_financial(financials, key, scale=1, as_percent=False):
    """Safely extract a financial metric, handling null and missing fields."""
    field = financials.get(key, {})
    v = field.get("v")
    if v is None:
        return "N/A"
    if as_percent:
        return f"{v * 100:.1f}%"
    if scale == 1e9:
        return f"${v / 1e9:.1f}B"
    if scale == 1e6:
        return f"${v / 1e6:.0f}M"
    return f"{v:.2f}"

companies = (
    report["Firmographics"]["Firmographic"]["firmographics"]["firmographics"]
)

print(f"{'Company':<20} {'Revenue':<15} {'EBITDA Margin':<18} {'Net Margin':<15} {'Market Cap'}")
print("-" * 90)

for co in companies:
    name = co["organization"]["name"]
    fin  = co["details"].get("financials", {})
    print(
        f"{name:<20} "
        f"{safe_financial(fin, 'Total revenue', scale=1e6):<15} "
        f"{safe_financial(fin, 'EBITDA margin (%)', as_percent=True):<18} "
        f"{safe_financial(fin, 'Net margin (%)', as_percent=True):<15} "
        f"{safe_financial(fin, 'Market cap', scale=1e9)}"
    )

product_data = (
    report["Product offerings"]
    ["Product offerings"]
    ["key_product_features"]
)

columns    = product_data["columns"]    # ordered list of permalinks
rows       = product_data["rows"]

# Build company-name lookup from firmographics
company_names = {
    co["details"].get("website", "").replace("https://", "").replace("http://", "").rstrip("/"): co["organization"]["name"]
    for co in report["Firmographics"]["Firmographic"]["firmographics"]["firmographics"]
}

# Print matrix
header = f"{'Feature':<40} " + "  ".join(f"{c[:12]:<12}" for c in columns)
print(header)
print("-" * (40 + 14 * len(columns)))

for row in rows:
    feature = row["category_name"]
    mapping = row["company_result_mapping"]
    cells   = "  ".join(f"{'✓' if mapping.get(c) == 'yes' else '✗':<12}" for c in columns)
    print(f"{feature:<40} {cells}")
    print(f"  {row['commentary'][:100]}...")
    print()

business_model = (
    report["Business model"]
    ["Business model"]
    ["business_model"]
)

for area_obj in business_model:
    area = area_obj["area"]
    print(f"\n{'='*60}")
    print(f"  {area}")
    print('='*60)
    for detail in area_obj["details"]:
        name  = detail["company_name"]
        desc  = detail["area_details"]
        print(f"\n  {name}:")
        print(f"    {desc[:200]}...")

import requests, time, concurrent.futures

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

COMPARISONS = {
    "payments":    ["stripe.com", "paypal.com", "square.com", "adyen.com"],
    "crm":         ["salesforce.com", "hubspot.com", "pipedrive.com", "zoho.com"],
    "spend_mgmt":  ["ramp.com", "expensify.com", "brex.com", "airbase.com"],
}

def submit_comparison(name, websites):
    r = requests.post(
        "https://api.wokelo.ai/api/workflow_manager/start/",
        headers=HEADERS,
        json={
            "workflow":      "player_comparison",
            "websites":      websites,
            "workbook_name": f"{name} Peer Comparison"
        }
    )
    return name, 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
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as pool:
    futures = {pool.submit(submit_comparison, name, urls): name for name, urls in COMPARISONS.items()}
    jobs = {}
    for f in concurrent.futures.as_completed(futures):
        name, report_id = f.result()
        jobs[name] = report_id
        print(f"Submitted: {name} → report_id {report_id}")

# Collect
reports = {}
for name, report_id in jobs.items():
    ok = poll_until_done(report_id)
    if ok:
        reports[name] = fetch_report(report_id)
        print(f"Collected: {name}")
    else:
        print(f"Failed: {name}")

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

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": 1002345, "file_type": "ppt"}
)

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

print("Saved payments_peer_comparison.pptx")

status_r = requests.get(
    "https://api.wokelo.ai/api/assets/get_notebook_status/",
    headers=HEADERS,
    params={"report_id": report_id}
)
if status_r.json().get("status") == "Failed":
    print(f"Report {report_id} failed. Resubmitting...")
    resubmit = requests.post(
        "https://api.wokelo.ai/api/workflow_manager/start/",
        headers=HEADERS,
        json={
            "workflow":  "player_comparison",
            "websites":  ["stripe.com", "paypal.com", "square.com"],
            "workbook_name": "Payments Comparison (retry)"
        }
    )
    new_id = resubmit.json()["report_id"]
    print(f"New report_id: {new_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")

# ❌ Not accepted by this API
"websites": ["salesforce", "hubspot"]         # Permalinks, not URLs

# ✅ Accepted — bare domain
"websites": ["salesforce.com", "hubspot.com"]

# ✅ Also accepted — full URL
"websites": ["https://www.salesforce.com", "https://www.hubspot.com"]

report_id = response.json()["report_id"]
save_to_db({"comparison_name": workbook_name, "report_id": report_id, "submitted_at": datetime.now()})

for wait in [20, 20, 30, 30, 60, 60, 120]:
    time.sleep(wait)
    status = get_status(report_id)
    if status in ("Completed", "Failed"):
        break

# ❌ TypeError when v is null
revenue_m = company["details"]["financials"]["Total revenue"]["v"] / 1e6

# ✅ Safe
fin = company["details"].get("financials", {})
revenue_raw = fin.get("Total revenue", {}).get("v")
revenue_m = revenue_raw / 1e6 if revenue_raw is not None else None

for row in key_product_features["rows"]:
    ramp_result = row["company_result_mapping"].get("ramp-financial", "unknown")

workbook_name = f"Payments Competitive Landscape — {datetime.today().strftime('%Y-%m-%d')}"