Custom Workflow

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

response = requests.post(
    "https://api.wokelo.ai/api/workflow_manager/start/",
    headers={
        "Authorization": "Bearer <YOUR_API_TOKEN>",
        "Content-Type": "application/json"
    },
    json={
        "workflow": "industry_research___custom_a842447",
        "industry_research_topic": "Electric vehicles"
    }
)
report_id = response.json()["report_id"]

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>")

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"Top-level sections: {list(report.keys())}")

Authorization: Bearer <YOUR_API_TOKEN>

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

{
  "report_id": 86220
}

report = result.json()

# Iterate top-level sections (predictable — named by workflow template)
for section_name, section_data in report.items():
    print(f"\n=== SECTION: {section_name} ===")

    # Iterate sub-keys within each section (UUID-suffixed — discover by iteration)
    for sub_key, sub_data in section_data.items():
        print(f"  Sub-key: {sub_key}")

        # Most sub-keys have a "summary" field for the main content
        summary = None
        if isinstance(sub_data, dict):
            summary = sub_data.get("summary") or sub_data.get("quick_snapshot")
        if summary:
            content = summary if isinstance(summary, str) else str(summary)[:200]
            print(f"  Content preview: {content[:200]}...")

report
├── "Investment Prioritization Scorecard"
│   └── "Opportunity Prioritization Scorecard"
│       ├── source: [...]
│       └── summary: markdown table of themes × business value × attractiveness
├── "Step 1: Company Information"
│   ├── "CP - Quick snapshot_{uuid}"
│   │   ├── quick_snapshot: {...}     ← firmographics + product details
│   │   └── sources: [...]
│   └── "CP - Executive summary_{uuid}"
│       ├── source: [...]
│       └── summary: markdown narrative
├── "Step 2: Company Intent Identification"
│   └── "Company Intent Identification"
│       ├── source: [...]
│       └── summary: markdown table of intent signals + hypothesis statements
└── "Step 3: Opportunity Mapping"
    └── "Theme Identification"
        ├── source: [...]
        └── summary: markdown narrative

{
  "report_id": 86220
}

import requests, time

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

submit = requests.post(
    "https://api.wokelo.ai/api/workflow_manager/start/",
    headers=HEADERS,
    json={
        "workflow":                "industry_research___custom_a842447",
        "industry_research_topic": "B2B Embedded Finance",
        "workbook_name":           "B2B Embedded Finance — Industry Attractiveness"
    }
)
report_id = submit.json()["report_id"]
print(f"Submitted. report_id: {report_id}")

import requests

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

# Step 1: Upload the CIM
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"]

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

report = result.json()

# --- Extract the scorecard summary table ---
scorecard_section = report.get("Investment Prioritization Scorecard", {})
for sub_key, sub_data in scorecard_section.items():
    summary = sub_data.get("summary", "")
    if summary:
        print("=== SCORECARD ===")
        print(summary[:1000])

# --- Extract company snapshot from Step 1 ---
step1 = report.get("Step 1: Company Information", {})
for sub_key, sub_data in step1.items():
    if "quick_snapshot" in sub_data:
        qs   = sub_data["quick_snapshot"]
        name = qs["company_firmographics"]["organization"]["name"]
        fin  = qs["company_firmographics"]["details"].get("financials", {})
        rev  = fin.get("revenue", {})
        print(f"\n=== {name} ===")
        if rev:
            print(f"Revenue: ${rev.get('value', 0) / 1e9:.1f}B ({rev.get('period', 'N/A')})")
    elif "summary" in sub_data:
        print(f"\n--- {sub_key.split('_')[0]} ---")
        print(sub_data["summary"][:500])

# --- Extract intent signals from Step 2 ---
step2 = report.get("Step 2: Company Intent Identification", {})
for sub_key, sub_data in step2.items():
    summary = sub_data.get("summary", "")
    if summary:
        print("\n=== INTENT SIGNALS (excerpt) ===")
        print(summary[:800])

# --- Print all step summaries ---
for section_name, section_data in report.items():
    print(f"\n{'='*60}")
    print(f"SECTION: {section_name}")
    for sub_key, sub_data in section_data.items():
        if isinstance(sub_data, dict) and "summary" in sub_data:
            s = sub_data["summary"]
            if isinstance(s, str):
                print(f"  [{sub_key[:40]}] {s[:200]}...")

import requests, time, concurrent.futures

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

COMPANIES = [
    ("air-canada",  "value_creation_e469641"),
    ("delta-airlines", "value_creation_e469641"),
    ("southwest-airlines", "ic_memo_(direct_investments)_02918b9"),
]

def submit_workflow(permalink, workflow_id):
    r = requests.post(
        "https://api.wokelo.ai/api/workflow_manager/start/",
        headers=HEADERS,
        json={"workflow": workflow_id, "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_workflow, p, w): p for p, w in COMPANIES}
    jobs = {}
    for f in concurrent.futures.as_completed(futures):
        permalink, report_id = f.result()
        jobs[permalink] = report_id
        print(f"Submitted: {permalink} → {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: {permalink}")

import requests

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

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

# Submit
submit_r = requests.post(
    "https://api.wokelo.ai/api/workflow_manager/start/",
    headers={**HEADERS, "Content-Type": "application/json"},
    json={
        "workflow":      "expert_call_synthesis_f6a6a60",
        "permalink":     "target-company-permalink",
        "custom_files":  [{"fileName": file_name}],
        "workbook_name": "Expert Call — Supply Chain VP"
    }
)
report_id = submit_r.json()["report_id"]
print(f"Synthesis submitted. report_id: {report_id}")

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": "value_creation_e469641", "permalink": "air-canada"}
    )
    print(f"New report_id: {resubmit.json()['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")

# ❌ Company workflow with no company identifier — will fail
{"workflow": "value_creation_e469641"}

# ✅ Company workflow with permalink
{"workflow": "value_creation_e469641", "permalink": "air-canada"}

# ❌ Industry workflow with a permalink instead of topic — will fail
{"workflow": "industry_research___custom_a842447", "permalink": "tesla-motors"}

# ✅ Industry workflow with a topic
{"workflow": "industry_research___custom_a842447", "industry_research_topic": "Electric vehicles"}

# Upload → get fileName → pass in custom_files
upload_r = requests.post("https://api.wokelo.ai/api/assets/upload/", ...)
file_name = upload_r.json()["fileName"]
json_body["custom_files"] = [{"fileName": file_name}]

# ❌ Brittle — assumes a specific UUID in the sub-key name
summary = report["Step 1: Company Information"]["CP - Quick snapshot_3b3f08c6-..."]["summary"]

# ✅ Resilient — discovers sub-keys by iteration
step1 = report.get("Step 1: Company Information", {})
for sub_key, sub_data in step1.items():
    if isinstance(sub_data, dict) and "summary" in sub_data:
        print(sub_data["summary"])

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