Alternative Datasets - Wokelo Docs

1. Overview

The Alternative Datasets APIs provide access to two proprietary third-party data sources that are not captured in standard firmographic or financial databases: G2 product reviews and Glassdoor employee reviews. Both are synchronous GET endpoints that return paginated data immediately in the HTTP response. Two endpoints, two data sources:

	Product Reviews	Employee Reviews
Endpoint	`GET /api/enterprise/company/product-reviews/`	`GET /api/enterprise/company/employee-reviews/`
Source	G2 (software product reviews)	Glassdoor (employee workplace reviews)
Response pattern	Synchronous — data returned immediately	Synchronous — data returned immediately
What you get	Overall rating, star distribution, individual review text	Aggregate sentiment ratings across 8 workplace dimensions, individual review records
Use case	Product due diligence, competitive positioning, customer sentiment	Talent health monitoring, cultural diligence, management assessment

Common use cases:

Pre-IC product due diligence — pull G2 product reviews for a target SaaS company and its top 3 competitors to compare customer satisfaction, identify recurring complaints, and surface NPS signals before a diligence sprint
Competitive product benchmarking — compare star distributions and review counts across a set of competitors to quantify perceived product quality at scale
Management assessment in CDD — use Glassdoor’s CEO approval rating, senior management score, and business outlook as quantitative proxies for leadership quality and workforce confidence
Talent and culture diligence — track culture_and_values_rating, work_life_balance_rating, and recommend_to_friend_rating over time to detect cultural deterioration or post-acquisition integration signals
Portfolio health monitoring — run both endpoints quarterly across a portfolio to surface early warning signals in customer perception or employee sentiment before they become widely reported
Customer voice analysis — use individual product review text as input to an LLM pipeline for theme extraction, sentiment classification, and feature gap analysis

Both APIs are synchronous. Results are returned directly in the HTTP response — no job submission or polling required.

2. Quick Start

Product Reviews — get G2 reviews for a company

curl --location 'https://api.wokelo.ai/api/enterprise/company/product-reviews/?company=salesforce&limit=30&offset=0' \
  --header 'Authorization: Bearer <YOUR_API_TOKEN>' \
  --header 'Content-Type: application/json'

Employee Reviews — get Glassdoor overview and reviews for a company

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

3. Authentication

All requests must include a Bearer token in the Authorization HTTP header.

Authorization: Bearer <YOUR_API_TOKEN>

API tokens are issued from your Wokelo account. Navigate to Account Details → API Credentials in the Wokelo dashboard to get your client id and client secret. Contact support@wokelo.ai if you do not yet have API access.

Never expose your token in client-side code, browser requests, or public repositories. A missing or invalid token returns 401 Unauthorized. A valid token without sufficient plan permissions returns 403 Forbidden.

4. Request Reference

Product Reviews

Endpoint

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

All parameters are passed as URL query parameters.

Parameter	Type	Required	Description
`company`	string	Required	Permalink of the company whose G2 product reviews to fetch (e.g. `"salesforce"`, `"hubspot"`). Use the Company Search API to look up a permalink by company name.
`limit`	integer	Optional	Maximum number of individual review records to return. Default `100`.
`offset`	integer	Optional	Number of review records to skip before returning results. Default `0`. Use with `limit` for pagination.

Full request example:

curl --location 'https://api.wokelo.ai/api/enterprise/company/product-reviews/?company=hubspot&limit=30&offset=0' \
  --header 'Authorization: Bearer <YOUR_API_TOKEN>' \
  --header 'Content-Type: application/json'

Employee Reviews

Endpoint

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

All parameters are passed as URL query parameters.

Parameter	Type	Required	Description
`company`	string	Required	Permalink of the company whose Glassdoor employee reviews to fetch (e.g. `"salesforce"`, `"zendesk"`). Use the Company Search API to look up a permalink by name.
`limit`	integer	Optional	Maximum number of individual review records to return. Default `100`.
`offset`	integer	Optional	Number of review records to skip before returning results. Default `0`. Use with `limit` for pagination.

Full request example:

curl --location 'https://api.wokelo.ai/api/enterprise/company/employee-reviews/?company=salesforce&limit=100&offset=0' \
  --header 'Authorization: Bearer <YOUR_API_TOKEN>' \
  --header 'Content-Type: application/json'

5. Response

Product Reviews response

{
  "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"
      }
    ]
  }
}

Top-level response fields:

Field	Type	Description
`status`	string	`"success"` when data was returned successfully.
`data`	object	The product reviews object for the requested company.

data object fields:

Field	Type	Description
`company`	string	The company permalink that was queried.
`product_name`	string	Name of the primary product indexed on G2 for this company (e.g. `"Slack"`, `"HubSpot Marketing Hub"`).
`rating`	float	Overall G2 rating on a 1.0–5.0 scale (e.g. `4.5`).
`star_distribution`	object	Count of reviews per star rating. Keys are `"1"` through `"5"` (strings); values are integers. The total across all keys equals the total review count.
`reviews`	object[]	Array of individual review records, up to `limit` entries. Each object contains at minimum `review_id` (integer) and `review_title` (string). May contain additional fields including review body text, reviewer role, date, and helpfulness votes depending on data availability.

The star_distribution keys are strings ("1", "2", etc.), not integers. When iterating or sorting, cast to int: sorted(star_distribution.keys(), key=int). The total review count is sum(star_distribution.values()).

Employee Reviews response

{
  "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": [ { ... } ]
  }
}

Top-level response fields:

Field	Type	Description
`status`	string	`"success"` when data was returned successfully.
`data`	object	The employee reviews object for the requested company.

data object fields:

Field	Type	Description
`company`	string	The company permalink that was queried.
`overview`	object	Aggregate rating summary across all Glassdoor reviews (see below).
`reviews`	object[]	Array of individual employee review records, up to `limit` entries.

overview fields — two different scales:

The overview object mixes two different scales. business_outlook_rating, ceo_rating, and recommend_to_friend_rating are approval ratios between 0.0 and 1.0 (e.g. 0.82 = 82% approval). All other rating fields (rating, compensation_and_benefits_rating, culture_and_values_rating, etc.) are scores on a 1.0–5.0 scale. Never display these raw without applying the correct scale — multiplying a ratio field by 5 to fit a star display will produce incorrect results.

Field	Scale	Description
`rating`	1.0–5.0	Overall Glassdoor score — the primary summary metric.
`business_outlook_rating`	0.0–1.0	Share of employees with a positive 6-month business outlook.
`ceo_rating`	0.0–1.0	CEO approval rate — share of employees who approve of the CEO.
`recommend_to_friend_rating`	0.0–1.0	Share of employees who would recommend the company to a friend.
`compensation_and_benefits_rating`	1.0–5.0	Employee satisfaction with pay and benefits.
`culture_and_values_rating`	1.0–5.0	Employee satisfaction with company culture and stated values.
`diversity_and_inclusion_rating`	1.0–5.0	Employee satisfaction with DEI practices.
`senior_management_rating`	1.0–5.0	Employee satisfaction with senior leadership.
`work_life_balance_rating`	1.0–5.0	Employee satisfaction with work-life balance.

6. Examples

Competitive product sentiment sweep

Fetch G2 ratings for a set of competing SaaS products and compare overall scores and star distributions.

curl --location 'https://api.wokelo.ai/api/enterprise/company/product-reviews/?company=hubspot&limit=500&offset=0' \
  --header 'Authorization: Bearer <YOUR_API_TOKEN>'

Sample response (product reviews — Salesforce/Slack):

{
  "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"
      }
    ]
  }
}

Paginating through all product reviews for LLM analysis

Retrieve the full review corpus for downstream theme extraction or sentiment analysis.

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

Employee sentiment benchmark — portfolio health check

Compare Glassdoor ratings across a portfolio of companies to surface cultural warning signals.

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', '—')}"
    )

Sample response (employee reviews — Salesforce):

{
  "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": []
  }
}

Combined product + employee sweep before IC meeting

Pull both data sources for a target company in two parallel calls to get a fast 360-degree view.

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

JavaScript / Node.js — both endpoints

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)}%`);
});

7. Error Handling

Both APIs use standard HTTP status codes and return errors synchronously.

Status	Meaning	Cause & Resolution
`200 OK`	Success	Data returned successfully.
`400 Bad Request`	Invalid parameters	Missing `company` parameter or invalid value. Check the `detail` field.
`401 Unauthorized`	Auth failed	The `Authorization` header is missing or contains an invalid token. Verify your key in Settings → API Keys.
`403 Forbidden`	Insufficient access	Your plan does not include access to this endpoint. Contact support@wokelo.ai.
`404 Not Found`	Company not found	The permalink could not be resolved, or no review data exists for this company. Verify the permalink using the Company Search API.
`429 Too Many Requests`	Rate limit exceeded	Implement exponential back-off. The response includes a `Retry-After` header.
`500 Internal Server Error`	Server error	Retry after a brief delay. If the issue persists, contact support@wokelo.ai.

Retry logic with exponential back-off:

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

8. Best Practices

Use permalinks, not company names or URLs Both endpoints accept only the company permalink as an identifier — not a display name or website URL. Use the Company Search API to resolve a name to its permalink before querying:

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"

star_distribution keys are strings — sort and access accordingly The five keys in star_distribution are string values "1" through "5", not integers. When iterating in order or computing a weighted average, cast to int explicitly:

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

Employee review overview uses two different scales — display them correctly Three fields (business_outlook_rating, ceo_rating, recommend_to_friend_rating) are approval ratios between 0.0 and 1.0. The remaining five rating fields are on a 1.0–5.0 scale. Multiply ratio fields by 100 to display as percentages; never multiply by 5:

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"

Fetch overview without individual reviews by setting limit=1 When you only need aggregate metrics (overall rating, star distribution, Glassdoor overview scores), set limit=1 to return a minimal review payload. The overview and star_distribution aggregate fields are always present regardless of limit:

# 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})

Paginate correctly for full-corpus review pulls Both endpoints return up to limit reviews per call (default 100). When building a full review corpus for LLM or NLP processing, paginate using offset and stop when the returned reviews array is empty:

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

Run both endpoints in parallel for pre-IC snapshots Both are synchronous and independent — fire them concurrently with concurrent.futures.ThreadPoolExecutor or asyncio to halve the total latency when you need both product and employee data:

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

Guard against missing companies — not all companies have review data G2 and Glassdoor coverage is concentrated in software and technology companies. For companies in industrial, financial, or other non-software sectors, review data may be absent. A 404 response or an empty reviews array with null rating fields indicates no data is indexed for that company:

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

Company Instant Enrichment

Structured firmographic, funding, and financial data from Wokelo’s native database — synchronous, results within seconds.

Company Deep Intelligence

AI-synthesised product portfolio, strategic initiative, and sentiment analysis — includes employee_sentiment and product_sentiment sections that complement raw review data.

Company News Monitoring

Real-time news feed for any company — synchronous, source-cited. Use alongside review data to combine sentiment signals with current event context.

Company Research

Full async intelligence report for a single company with product insights, transaction highlights, and executive summary — PDF/DOCX/PPT export.

Peer Comparison

Side-by-side competitive benchmarking including product feature matrices and business model analysis — use after review data to add structured competitive context.

Supporting APIs

Company Search — used to resolve company names to permalinks before querying either review endpoint.

Documentation Index

​1. Overview

​2. Quick Start

​3. Authentication

​4. Request Reference

​Product Reviews

​Employee Reviews

​5. Response

​Product Reviews response

​Employee Reviews response

​6. Examples

​Competitive product sentiment sweep

​Paginating through all product reviews for LLM analysis

​Employee sentiment benchmark — portfolio health check

​Combined product + employee sweep before IC meeting

​JavaScript / Node.js — both endpoints

​7. Error Handling

​8. Best Practices

​9. Related APIs

Company Instant Enrichment

Company Deep Intelligence

Company News Monitoring

Company Research

Peer Comparison

Supporting APIs

1. Overview

2. Quick Start

3. Authentication

4. Request Reference

Product Reviews

Employee Reviews

5. Response

Product Reviews response

Employee Reviews response

6. Examples

Competitive product sentiment sweep

Paginating through all product reviews for LLM analysis

Employee sentiment benchmark — portfolio health check

Combined product + employee sweep before IC meeting

JavaScript / Node.js — both endpoints

7. Error Handling

8. Best Practices

9. Related APIs