# AmbitionBox Reviews Scraper (`automation-lab/ambitionbox-reviews-scraper`) Actor

Export public AmbitionBox employee reviews with ratings, pros, cons, roles, locations, work policies, helpfulness, and company culture aggregates. Run by slug or URL, filter results, schedule monitoring, and download JSON, CSV, or Excel—no login required.

- **URL**: https://apify.com/automation-lab/ambitionbox-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## AmbitionBox Reviews Scraper

Export public **AmbitionBox employee reviews** as structured JSON, CSV, Excel, XML, or RSS.

Give the Actor a company slug such as `tcs` or an AmbitionBox company review URL. It returns individual reviews with ratings, pros, cons, designations, departments, locations, work policies, verification signals, and denormalized company culture context.

No AmbitionBox login or API key is required.

### What does AmbitionBox Reviews Scraper do?

AmbitionBox Reviews Scraper turns public company review pages into analysis-ready records.

It can:

- 📝 Export one row per employee review.
- ⭐ Capture overall and seven category ratings.
- 💬 Collect pros, cons, and review titles.
- 🧑‍💻 Extract designation, department, location, and employment type.
- 🏠 Identify WFO, WFH, and Hybrid work-policy reviews.
- ✅ Preserve AmbitionBox verification and helpfulness signals.
- 📊 Add company-wide ratings, rating distribution, culture themes, and work-policy mix to every row.
- 🔎 Filter by rating, designation, location, work policy, or verified status.
- 🔁 Process several companies in one scheduled run.

The scraper uses AmbitionBox's current server-rendered data and public structured review endpoints rather than brittle visual selectors.

### Who is AmbitionBox Reviews Scraper for?

**Employer-brand and people teams**

- Monitor recent employee feedback about your company.
- Track repeated culture, compensation, and management themes.
- Compare review velocity and ratings with peer employers.

**Recruiters and talent-intelligence teams**

- Research how candidates may perceive a target employer.
- Compare work-policy and role-specific experiences.
- Build repeatable company research before outreach campaigns.

**Candidates and career researchers**

- Export reviews for offline comparison.
- Focus on a city, designation, rating range, or work policy.
- Review both individual comments and company-level context.

**Analysts and data teams**

- Build employer sentiment dashboards.
- Schedule recurring snapshots for trend analysis.
- Feed structured records into warehouses, notebooks, or AI workflows.

### Why use this AmbitionBox review extractor?

- **Focused reviews-only contract** — no mixed salary, interview, or job rows.
- **Analysis-ready output** — every row includes company aggregate context.
- **Source IDs included** — deduplicate recurring snapshots by `reviewId`.
- **Strict input validation** — unrelated websites and non-review AmbitionBox paths fail closed.
- **Useful filters** — reduce downstream cleaning for role, city, rating, policy, or verified reviews.
- **Reliable delivery** — conservative concurrency, India routing, cookie-preserving sessions, and bounded retries.
- **Apify-native automation** — API access, schedules, webhooks, datasets, exports, and integrations.
- **No target login** — the Actor reads only anonymously visible public review data.

### What AmbitionBox review data can you extract?

| Category | Fields |
|---|---|
| Identity | `reviewId`, `companyId`, `companyName`, `companySlug` |
| Review | `rating`, `reviewTitle`, `pros`, `cons`, `reviewedOn`, `reviewUrl` |
| Reviewer context | `designation`, `department`, `location`, `employmentType`, `workPolicy` |
| Signals | `verified`, `helpfulCount`, `notHelpfulCount`, `employerResponded` |
| Category ratings | salary, skill development, job security, promotions, work satisfaction, company culture, work-life balance |
| Company ratings | overall, job security, work life, culture, skills, satisfaction, compensation, career growth |
| Company aggregates | total reviews, rating distribution, work-policy distribution, top mentions, positive and critical themes |
| Run metadata | `scrapedAt` |

Optional values are omitted when AmbitionBox does not publish them for a specific review. The Actor does not invent missing values.

### How much does it cost to scrape AmbitionBox reviews?

The Actor uses pay-per-event pricing:

- **$0.005** start fee per run.
- **$0.00077011 per review** on the Bronze tier before volume discounts.

Example estimates:

| Reviews | Estimated Bronze charge |
|---:|---:|
| 20 | $0.0204 |
| 100 | $0.0820 |
| 1,000 | $0.7751 |

Apify plan tiers can receive lower per-review prices. Residential proxy bandwidth and compute are handled by the Actor; users pay the displayed Actor charge.

With the Apify Free plan's monthly platform credit, small review exports can usually be tested before scaling. Check the live Pricing tab because platform prices can change.

### How to scrape AmbitionBox employee reviews

1. Open **AmbitionBox Reviews Scraper** on Apify.
2. Add one or more company slugs, such as `tcs` or `infosys`.
3. Alternatively, paste a URL such as `https://www.ambitionbox.com/reviews/tcs-reviews`.
4. Choose the maximum reviews per company and total review limit.
5. Optionally add rating, designation, location, work-policy, or verified-only filters.
6. Click **Start**.
7. Preview the dataset or export it as JSON, CSV, Excel, XML, or RSS.
8. Save the input as a Task or schedule it for recurring monitoring.

A low-cost first input:

```json
{
  "companies": ["tcs"],
  "maxReviewsPerCompany": 5,
  "totalMaxReviews": 5,
  "maxPagesPerCompany": 2,
  "maxConcurrency": 1
}
````

A multi-company monitoring input:

```json
{
  "companies": ["tcs", "infosys", "wipro", "hcl-technologies"],
  "maxReviewsPerCompany": 50,
  "totalMaxReviews": 200,
  "maxConcurrency": 3
}
```

A filtered research input:

```json
{
  "companies": ["https://www.ambitionbox.com/reviews/infosys-reviews"],
  "minRating": 1,
  "maxRating": 3,
  "location": "Pune",
  "workPolicy": "Hybrid",
  "verifiedOnly": true,
  "maxReviewsPerCompany": 25
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `companies` | array | required | Bare company slugs or AmbitionBox `/reviews/` URLs |
| `maxReviewsPerCompany` | integer | 20 | Maximum matching reviews saved per company |
| `totalMaxReviews` | integer | 100 | Maximum reviews saved across all companies |
| `minRating` | integer | — | Minimum overall review rating, 1–5 |
| `maxRating` | integer | — | Maximum overall review rating, 1–5 |
| `designation` | string | — | Case-insensitive job-profile text filter |
| `location` | string | — | Case-insensitive job-location text filter |
| `workPolicy` | string | `any` | `any`, `WFO`, `WFH`, or `Hybrid` |
| `verifiedOnly` | boolean | false | Keep only reviews marked verified |
| `maxPagesPerCompany` | integer | 20 | Safety limit on pages scanned to find filter matches |
| `maxConcurrency` | integer | 3 | Companies fetched in parallel; maximum 5 |
| `maxRequestRetries` | integer | 5 | Session rotations after a network or anti-bot response |
| `proxyConfiguration` | object | Residential IN | Advanced proxy configuration |

`maxReviewsPerCompany` limits saved rows. When filters are active, the Actor may scan several source pages to find that many matches, bounded by `maxPagesPerCompany`.

### Output example

```json
{
  "reviewId": 80482915,
  "companyId": 42,
  "companyName": "TCS",
  "companySlug": "tcs",
  "rating": 1,
  "ratingSalary": 1,
  "ratingSkillDevelopment": 2,
  "ratingJobSecurity": 1,
  "designation": "Transformation Manager",
  "department": "Compensation & Benefits",
  "location": "Bengaluru",
  "employmentType": "permanent",
  "workPolicy": "WFO",
  "pros": "Public review text from AmbitionBox",
  "cons": "Public review text from AmbitionBox",
  "verified": false,
  "employerResponded": false,
  "reviewedOn": "2026-07-22",
  "reviewUrl": "https://www.ambitionbox.com/reviews/tcs-reviews?rid=80482915",
  "companyOverallRating": 3.3,
  "companyTotalReviews": 117292,
  "companyWorkPolicyDistribution": "Work from office: 81%; Hybrid: 15%; Permanent work from home: 4%",
  "scrapedAt": "2026-07-23T00:00:00.000Z"
}
```

The example illustrates field shape. Review text and aggregate values change as AmbitionBox publishes new data.

### Filter AmbitionBox reviews

Filters are evaluated against the source values in each review:

- Rating bounds require a parseable numeric rating and fail closed when absent.
- Designation and location use case-insensitive substring matching.
- Work policy requires the exact AmbitionBox policy code.
- `verifiedOnly` requires AmbitionBox's boolean verified flag.

A valid source request with no matching reviews finishes successfully with an empty dataset and a warning. A source extraction failure exits non-zero instead of silently returning success.

### Tips for best results

- Start with 5–20 reviews before increasing limits.
- Use company slugs when you already know the AmbitionBox URL name.
- Use full review URLs when copying a company from your browser.
- Keep concurrency at 3 or lower for stable recurring runs.
- Raise `maxPagesPerCompany` only for selective filters.
- Use `reviewId` to deduplicate scheduled snapshots.
- Store `scrapedAt` and `reviewedOn` separately for trend analysis.
- Keep the default Residential India routing unless you have tested another route.

### Schedule employer-review monitoring

Create an Apify Task with your company list and review limit. Then add a daily, weekly, or monthly schedule.

For incremental workflows:

1. Run the Actor on a schedule.
2. Read the default dataset through the API.
3. Compare `reviewId` with your stored IDs.
4. Send only unseen reviews to your dashboard, warehouse, or alert channel.

The Actor currently exports snapshots. It does not maintain cross-run state or suppress previously seen reviews automatically.

### Integrations

**AmbitionBox Reviews Scraper → Google Sheets**

Append recent reviews to a shared employer-brand tracker and build rating pivots by company, role, or location.

**AmbitionBox Reviews Scraper → Slack or Microsoft Teams**

Use an Apify webhook with Make or Zapier to alert a people team when a scheduled run finds new low-rating reviews.

**AmbitionBox Reviews Scraper → BigQuery or Snowflake**

Load scheduled datasets into a warehouse, deduplicate by `reviewId`, and model rating or culture trends over time.

**AmbitionBox Reviews Scraper → AI sentiment workflow**

Send `pros` and `cons` to an approved language model to classify themes while retaining source IDs and URLs for auditability.

**AmbitionBox Reviews Scraper → Looker Studio or Power BI**

Build employer-comparison dashboards from review-level ratings and denormalized company aggregates.

### Use the Apify API with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ambitionbox-reviews-scraper').call({
  companies: ['tcs', 'infosys'],
  maxReviewsPerCompany: 20,
  totalMaxReviews: 40,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ambitionbox-reviews-scraper').call(run_input={
    'companies': ['tcs'],
    'maxReviewsPerCompany': 20,
    'totalMaxReviews': 20,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ambitionbox-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": ["tcs"],
    "maxReviewsPerCompany": 20,
    "totalMaxReviews": 20
  }'
```

After the run finishes, fetch items from the run's `defaultDatasetId`.

### Use AmbitionBox Reviews Scraper with AI agents via MCP

The Actor can be used by AI assistants through Apify's hosted [Model Context Protocol integration](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/ambitionbox-reviews-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ambitionbox-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Use `automation-lab/ambitionbox-reviews-scraper` to export the 20 latest TCS employee reviews."
- "Collect verified Infosys reviews from Pune and summarize recurring pros and cons."
- "Compare work-policy and company-culture ratings for TCS, Infosys, Wipro, and HCL Technologies."

Your AI client authenticates with your Apify account and can start the Actor as a tool.

### Is it legal to scrape AmbitionBox reviews?

This Actor accesses anonymously visible public review content. It does not log in, bypass private employer analytics, solve CAPTCHAs, or collect reviewer contact details.

Scraping public information is generally permitted in many jurisdictions, but rules depend on your location and use case. Users are responsible for complying with AmbitionBox's terms, applicable privacy and database laws, employment regulations, and contractual obligations.

Use the data ethically:

- Collect only what you need.
- Avoid attempts to identify anonymous reviewers.
- Do not use review data for harassment or unlawful employment discrimination.
- Honor deletion, correction, retention, and access obligations that apply to your organization.
- Seek legal advice for high-risk or large-scale uses.

### Limitations

- AmbitionBox uses Akamai protection, so Residential India proxy routing is normally required.
- The Actor supports public company review pages only.
- Jobs, salaries, interviews, employer dashboards, and private analytics are outside V1.
- AmbitionBox may omit helpfulness, role, location, or optional text on individual reviews.
- Rating and aggregate values change as the source receives new reviews.
- Selective filters may return fewer rows before `maxPagesPerCompany` is reached.
- Source layout or endpoint changes can temporarily require an Actor update.
- Reviewer identity is intentionally not inferred from anonymous content.

### Troubleshooting

**Why did my run return no reviews?**

Check that the slug exists and that your filters are not too narrow. Remove filters or raise `maxPagesPerCompany`. Logs distinguish zero filter matches from extraction failures.

**Why does an AmbitionBox URL fail validation?**

Use a company review URL shaped like `https://www.ambitionbox.com/reviews/tcs-reviews`. Overview, salary, interview, job, search, and third-party URLs are rejected by the reviews-only contract.

**Why do some fields not appear?**

Optional fields are omitted when AmbitionBox does not publish them for a review. This is preferable to empty placeholders or guessed data.

**Why can runs take longer with filters?**

The Actor scans source pages until it finds enough matching reviews or reaches the page safety limit. Narrow filters require more source requests.

### FAQ

**How fast is the AmbitionBox scraper?**

A small single-company run normally finishes in under two minutes. Larger multi-company or selective-filter runs take longer because requests use conservative concurrency and protected-source retries.

**Does it require an AmbitionBox account?**

No. It accesses only public company review data that is visible without logging in.

**Can I scrape several companies at once?**

Yes. Add multiple slugs or review URLs to `companies` and set per-company and total limits.

**Can I scrape only one-star reviews?**

Yes. Set both `minRating` and `maxRating` to `1`.

**Can I filter by job title or city?**

Yes. Use `designation` and `location`; both are case-insensitive substring filters.

**Does this replace an official AmbitionBox API?**

It provides an Apify API for public review exports. It is not affiliated with AmbitionBox and is not an official AmbitionBox API.

**How should I track new reviews?**

Schedule snapshots and deduplicate by the stable numeric `reviewId`. Keep `scrapedAt` to identify when each snapshot was collected.

**What happens when AmbitionBox blocks a request?**

The Actor rotates the full proxy session and retries with bounded exponential backoff. Persistent extraction failure returns a failed run rather than an empty successful dataset.

### Other employer-review and labor-market scrapers

Explore related Automation Labs actors:

- [Glassdoor Reviews Scraper](https://apify.com/automation-lab/glassdoor-reviews-scraper)
- [Indeed Reviews Scraper](https://apify.com/automation-lab/indeed-reviews-scraper)
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper)
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)
- [Naukri Jobs Scraper](https://apify.com/automation-lab/naukri-jobs-scraper)
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper)

Use related actors only when you need another source or workflow. AmbitionBox Reviews Scraper remains focused on public AmbitionBox employee reviews.

### Support

If a valid public review URL stops working, open an issue from the Actor's **Issues** tab.

Include:

- The input with secrets removed.
- The failed run URL.
- The company slug or public review URL.
- The expected and actual behavior.

Do not include Apify tokens, private proxy credentials, or personal employee information.

# Actor input Schema

## `companies` (type: `array`):

Add AmbitionBox company slugs such as tcs or full /reviews/... URLs.

## `maxReviewsPerCompany` (type: `integer`):

Maximum matching employee reviews saved for each company.

## `totalMaxReviews` (type: `integer`):

Maximum employee reviews saved across all companies.

## `minRating` (type: `integer`):

Save only reviews at or above this overall rating.

## `maxRating` (type: `integer`):

Save only reviews at or below this overall rating.

## `designation` (type: `string`):

Case-insensitive text matched against the reviewer's job profile.

## `location` (type: `string`):

Case-insensitive text matched against the reviewer's job location.

## `workPolicy` (type: `string`):

Save reviews for any, office, remote, or hybrid work policies.

## `verifiedOnly` (type: `boolean`):

Save only records marked verified by AmbitionBox.

## `maxPagesPerCompany` (type: `integer`):

Safety limit for source pages scanned while finding reviews that match filters.

## `maxConcurrency` (type: `integer`):

Number of companies fetched in parallel. Keep this low for AmbitionBox.

## `maxRequestRetries` (type: `integer`):

Proxy-session rotations attempted after an Akamai or network failure.

## `proxyConfiguration` (type: `object`):

Residential proxy routing in India is recommended and used by default.

## Actor input object example

```json
{
  "companies": [
    "tcs"
  ],
  "maxReviewsPerCompany": 5,
  "totalMaxReviews": 5,
  "workPolicy": "any",
  "verifiedOnly": false,
  "maxPagesPerCompany": 2,
  "maxConcurrency": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

Table view of employee reviews with role, location, text, rating, and company context.

## `dataset` (type: `string`):

Complete default dataset using the employee-review view.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "tcs"
    ],
    "maxReviewsPerCompany": 5,
    "totalMaxReviews": 5,
    "workPolicy": "any",
    "verifiedOnly": false,
    "maxPagesPerCompany": 2,
    "maxConcurrency": 1,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ambitionbox-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companies": ["tcs"],
    "maxReviewsPerCompany": 5,
    "totalMaxReviews": 5,
    "workPolicy": "any",
    "verifiedOnly": False,
    "maxPagesPerCompany": 2,
    "maxConcurrency": 1,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ambitionbox-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "tcs"
  ],
  "maxReviewsPerCompany": 5,
  "totalMaxReviews": 5,
  "workPolicy": "any",
  "verifiedOnly": false,
  "maxPagesPerCompany": 2,
  "maxConcurrency": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call automation-lab/ambitionbox-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/ambitionbox-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AmbitionBox Reviews Scraper",
        "description": "Export public AmbitionBox employee reviews with ratings, pros, cons, roles, locations, work policies, helpfulness, and company culture aggregates. Run by slug or URL, filter results, schedule monitoring, and download JSON, CSV, or Excel—no login required.",
        "version": "0.1",
        "x-build-id": "meThTVwFL8A98aKM3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ambitionbox-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ambitionbox-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ambitionbox-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ambitionbox-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ambitionbox-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ambitionbox-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "🏢 Companies or review URLs",
                        "type": "array",
                        "description": "Add AmbitionBox company slugs such as tcs or full /reviews/... URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Reviews per company",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum matching employee reviews saved for each company.",
                        "default": 20
                    },
                    "totalMaxReviews": {
                        "title": "Total review limit",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum employee reviews saved across all companies.",
                        "default": 100
                    },
                    "minRating": {
                        "title": "Minimum review rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Save only reviews at or above this overall rating."
                    },
                    "maxRating": {
                        "title": "Maximum review rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Save only reviews at or below this overall rating."
                    },
                    "designation": {
                        "title": "Designation contains",
                        "type": "string",
                        "description": "Case-insensitive text matched against the reviewer's job profile."
                    },
                    "location": {
                        "title": "Location contains",
                        "type": "string",
                        "description": "Case-insensitive text matched against the reviewer's job location."
                    },
                    "workPolicy": {
                        "title": "Work policy",
                        "enum": [
                            "any",
                            "WFO",
                            "WFH",
                            "Hybrid"
                        ],
                        "type": "string",
                        "description": "Save reviews for any, office, remote, or hybrid work policies.",
                        "default": "any"
                    },
                    "verifiedOnly": {
                        "title": "Verified reviews only",
                        "type": "boolean",
                        "description": "Save only records marked verified by AmbitionBox.",
                        "default": false
                    },
                    "maxPagesPerCompany": {
                        "title": "Maximum pages scanned per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety limit for source pages scanned while finding reviews that match filters.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Company concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of companies fetched in parallel. Keep this low for AmbitionBox.",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Proxy-session rotations attempted after an Akamai or network failure.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy routing in India is recommended and used by default."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
