Alternative Datasets

import requests

response = requests.get(
    "https://api.wokelo.ai/api/enterprise/company/employee-reviews/",
    headers={"Authorization": "Bearer <YOUR_API_TOKEN>"},
    params={
        "company": "salesforce",
        "limit":   50,
        "offset":  0
    }
)
data = response.json()["data"]
overview = data["overview"]
print(f"Overall rating: {overview['rating']} / 5.0")
print(f"CEO approval: {overview['ceo_rating'] * 100:.0f}%")
print(f"Would recommend: {overview['recommend_to_friend_rating'] * 100:.0f}%")

Authorization: Bearer <YOUR_API_TOKEN>

GET https://api.wokelo.ai/api/enterprise/company/product-reviews/

GET https://api.wokelo.ai/api/enterprise/company/employee-reviews/

{
  "status": "success",
  "data": {
    "company": "salesforce",
    "product_name": "Slack",
    "rating": 4.5,
    "star_distribution": {
      "1": 128,
      "2": 270,
      "3": 1239,
      "4": 7083,
      "5": 25056
    },
    "reviews": [
      {
        "review_id": 10674077,
        "review_title": "Easy to use enterprise communication platform"
      }
    ]
  }
}

{
  "status": "success",
  "data": {
    "company": "salesforce",
    "overview": {
      "rating": 4.1,
      "business_outlook_rating": 0.71,
      "ceo_rating": 0.82,
      "recommend_to_friend_rating": 0.8,
      "compensation_and_benefits_rating": 4.4,
      "culture_and_values_rating": 4.0,
      "diversity_and_inclusion_rating": 4.2,
      "senior_management_rating": 3.6,
      "work_life_balance_rating": 3.9
    },
    "reviews": [ { ... } ]
  }
}

{
  "status": "success",
  "data": {
    "company": "salesforce",
    "product_name": "Slack",
    "rating": 4.5,
    "star_distribution": {
      "1": 128,
      "2": 270,
      "3": 1239,
      "4": 7083,
      "5": 25056
    },
    "reviews": [
      {
        "review_id": 10674077,
        "review_title": "Easy to use enterprise communication platform"
      }
    ]
  }
}

import requests

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

def get_all_product_reviews(company, page_size=200):
    all_reviews = []
    offset = 0

    while True:
        r = requests.get(
            "https://api.wokelo.ai/api/enterprise/company/product-reviews/",
            headers=HEADERS,
            params={"company": company, "limit": page_size, "offset": offset}
        )
        data = r.json().get("data", {})

        if offset == 0:
            # Capture overview from first page
            print(f"{data.get('product_name')}: {data.get('rating')}/5.0")
            total_available = sum(data.get("star_distribution", {}).values())
            print(f"Total reviews available: {total_available}")

        batch = data.get("reviews", [])
        if not batch:
            break

        all_reviews.extend(batch)
        print(f"  Fetched {len(all_reviews)} reviews...")
        offset += page_size

    return all_reviews

reviews = get_all_product_reviews("hubspot")
print(f"\nTotal retrieved: {len(reviews)} reviews")

# Feed review titles to LLM for theme analysis
review_titles = [r["review_title"] for r in reviews if r.get("review_title")]
print(f"Review titles for analysis: {len(review_titles)}")

import requests

HEADERS = {"Authorization": "Bearer <YOUR_API_TOKEN>"}
PORTFOLIO = ["zendesk", "freshworks", "salesforce", "hubspot", "intercom"]

def get_employee_overview(company):
    r = requests.get(
        "https://api.wokelo.ai/api/enterprise/company/employee-reviews/",
        headers=HEADERS,
        params={"company": company, "limit": 1}
    )
    overview = r.json().get("data", {}).get("overview", {})
    return {"company": company, **overview}

results = [get_employee_overview(c) for c in PORTFOLIO]

# Sort by overall rating
results.sort(key=lambda x: x.get("rating", 0), reverse=True)

print(f"{'Company':<15} {'Rating':<8} {'CEO %':<8} {'Recommend %':<14} {'Culture':<10} {'Sr Mgmt'}")
print("-" * 75)
for r in results:
    print(
        f"{r['company']:<15} "
        f"{r.get('rating', '—'):<8} "
        f"{round(r.get('ceo_rating', 0) * 100):<8} "
        f"{round(r.get('recommend_to_friend_rating', 0) * 100):<14} "
        f"{r.get('culture_and_values_rating', '—'):<10} "
        f"{r.get('senior_management_rating', '—')}"
    )

{
  "status": "success",
  "data": {
    "company": "salesforce",
    "overview": {
      "rating": 4.1,
      "business_outlook_rating": 0.71,
      "ceo_rating": 0.82,
      "recommend_to_friend_rating": 0.8,
      "compensation_and_benefits_rating": 4.4,
      "culture_and_values_rating": 4.0,
      "diversity_and_inclusion_rating": 4.2,
      "senior_management_rating": 3.6,
      "work_life_balance_rating": 3.9
    },
    "reviews": []
  }
}

import requests, concurrent.futures

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

def get_product_reviews(company):
    r = requests.get(
        "https://api.wokelo.ai/api/enterprise/company/product-reviews/",
        headers=HEADERS,
        params={"company": company, "limit": 50}
    )
    return r.json().get("data", {})

def get_employee_reviews(company):
    r = requests.get(
        "https://api.wokelo.ai/api/enterprise/company/employee-reviews/",
        headers=HEADERS,
        params={"company": company, "limit": 50}
    )
    return r.json().get("data", {})

# Fetch both in parallel
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool:
    product_future  = pool.submit(get_product_reviews,  TARGET)
    employee_future = pool.submit(get_employee_reviews, TARGET)
    product_data    = product_future.result()
    employee_data   = employee_future.result()

# Product summary
prod_total = sum(product_data.get("star_distribution", {}).values())
print(f"Product: {product_data.get('product_name')} | {product_data.get('rating')}/5.0 ({prod_total} reviews)")

star_dist = product_data.get("star_distribution", {})
for star in sorted(star_dist.keys(), key=int, reverse=True):
    count = star_dist[star]
    pct   = round(count / prod_total * 100, 1) if prod_total > 0 else 0
    bar   = "█" * int(pct / 2)
    print(f"  {star}★  {bar} {pct}% ({count})")

# Employee summary
ov = employee_data.get("overview", {})
print(f"\nEmployees: {ov.get('rating')}/5.0 overall")
print(f"  CEO approval:   {round(ov.get('ceo_rating', 0) * 100)}%")
print(f"  Would recommend:{round(ov.get('recommend_to_friend_rating', 0) * 100)}%")
print(f"  Culture:        {ov.get('culture_and_values_rating')}/5.0")
print(f"  Sr Management:  {ov.get('senior_management_rating')}/5.0")
print(f"  Work-life:      {ov.get('work_life_balance_rating')}/5.0")
print(f"  Compensation:   {ov.get('compensation_and_benefits_rating')}/5.0")

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

const API_KEY = process.env.WOKELO_API_KEY;

async function getProductReviews(company, limit = 100, offset = 0) {
  const params = new URLSearchParams({ company, limit, offset });
  const res = await fetch(
    `https://api.wokelo.ai/api/enterprise/company/product-reviews/?${params}`,
    { headers: { "Authorization": `Bearer ${API_KEY}` } }
  );
  if (!res.ok) throw new Error(`API error: ${res.status}`);
  return (await res.json()).data;
}

async function getEmployeeReviews(company, limit = 100, offset = 0) {
  const params = new URLSearchParams({ company, limit, offset });
  const res = await fetch(
    `https://api.wokelo.ai/api/enterprise/company/employee-reviews/?${params}`,
    { headers: { "Authorization": `Bearer ${API_KEY}` } }
  );
  if (!res.ok) throw new Error(`API error: ${res.status}`);
  return (await res.json()).data;
}

// Example: pre-IC snapshot
Promise.all([
  getProductReviews("hubspot", 1),
  getEmployeeReviews("hubspot", 1)
]).then(([product, employee]) => {
  console.log(`Product: ${product.product_name} — ${product.rating}/5.0`);
  const ov = employee.overview;
  console.log(`Employees: ${ov.rating}/5.0 | CEO ${Math.round(ov.ceo_rating * 100)}% | Recommend ${Math.round(ov.recommend_to_friend_rating * 100)}%`);
});

import time, requests

def fetch_with_retry(endpoint, params, api_key, max_retries=3):
    headers = {"Authorization": f"Bearer {api_key}"}
    for attempt in range(max_retries):
        try:
            r = requests.get(endpoint, headers=headers, params=params, timeout=30)
            if r.status_code == 429:
                time.sleep(2 ** attempt)
                continue
            r.raise_for_status()
            return r.json()
        except requests.exceptions.Timeout:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    raise Exception(f"Failed after {max_retries} attempts")

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

dist = data["star_distribution"]

# ❌ Dict order and string comparison may not sort numerically
for star, count in dist.items():
    print(star, count)

# ✅ Sort numerically
for star in sorted(dist.keys(), key=int):
    print(f"{star}★: {dist[star]}")

# Weighted average (should match data["rating"])
total = sum(dist.values())
weighted = sum(int(star) * count for star, count in dist.items()) / total

ov = data["overview"]

# ❌ Incorrect — treating a ratio as a star score
print(f"CEO: {ov['ceo_rating']}/5.0")      # Shows "0.82/5.0" — wrong

# ✅ Correct — display ratio as percentage, star fields as scores
print(f"CEO approval: {ov['ceo_rating'] * 100:.0f}%")          # "82%"
print(f"Culture: {ov['culture_and_values_rating']}/5.0")        # "4.0/5.0"

# Fast overview-only calls
product_summary  = requests.get(product_reviews_url,  headers=HEADERS, params={"company": c, "limit": 1})
employee_summary = requests.get(employee_reviews_url, headers=HEADERS, params={"company": c, "limit": 1})

all_reviews, offset = [], 0
while True:
    r = requests.get(endpoint, headers=HEADERS, params={"company": c, "limit": 200, "offset": offset})
    batch = r.json()["data"].get("reviews", [])
    if not batch:
        break
    all_reviews.extend(batch)
    offset += 200

with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool:
    pf = pool.submit(get_product_reviews,  company)
    ef = pool.submit(get_employee_reviews, company)
    product_data, employee_data = pf.result(), ef.result()

rating = data.get("rating")
if rating is None:
    print(f"No G2 data available for {company}")
else:
    print(f"Rating: {rating}/5.0")