# Glassdoor Jobs Scraper (`khadinakbar/glassdoor-jobs-scraper`) Actor

Scrape Glassdoor job listings with title, company, location, salary, posted date, rating, apply URL, and source URL. MCP optimized for recruiters and job-market research.

- **URL**: https://apify.com/khadinakbar/glassdoor-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 job scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Glassdoor Jobs Scraper

Scrape Glassdoor job listings for recruiters, HR analytics teams, job-market researchers, and AI agents that need structured job data with source links and predictable pricing.

### What It Extracts

The actor searches Glassdoor jobs by role, skill, company, location, and optional recency filters. It returns one flat dataset row per job so downstream systems can read it directly from Apify datasets, CSV, JSON, or the Apify MCP server.

| Field                                                      | Description                                     |
| ---------------------------------------------------------- | ----------------------------------------------- |
| `title`                                                    | Job title shown by Glassdoor                    |
| `companyName`                                              | Hiring company name                             |
| `companyRating`                                            | Visible Glassdoor company rating when available |
| `location`                                                 | Job location or remote label                    |
| `salaryText`                                               | Raw visible salary range                        |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Parsed salary fields when recognizable          |
| `datePosted`                                               | Posted age or date visible on the listing       |
| `employmentType`, `easyApply`, `remoteType`                | Job flags when Glassdoor exposes them           |
| `description`                                              | Compact listing text or embedded description    |
| `jobUrl`, `applyUrl`, `sourceUrl`                          | Job, apply, and source links                    |

### When To Use It

Use this actor when you need fresh Glassdoor job listings for salary benchmarking, hiring signal monitoring, recruiter sourcing, job-board enrichment, or LLM grounding. It is especially useful when an agent needs a small, current sample such as "find 25 software engineer jobs in New York with salaries and application links."

Do not use it for Glassdoor company reviews, interview questions, company overview pages, or salary-only pages. Those are separate Glassdoor data surfaces and need different contracts. This actor also does not log in to Glassdoor, ask for user cookies, or scrape private account data.

### Input Options

The fastest path is a keyword and a location:

```json
{
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "country": "US",
    "maxResults": 50,
    "daysOld": 7,
    "includeNoSalaryJobs": true,
    "deduplicate": true
}
````

`maxResults` is both the output cap and the billable job-event cap. Set `includeNoSalaryJobs` to `false` when you only want listings with visible compensation.

### Output Example

```json
{
    "jobId": "1009550830112",
    "title": "Senior Software Engineer",
    "companyName": "Scribd Inc.",
    "companyRating": 3.8,
    "location": "New York, NY",
    "salaryText": "$126K - $196K (Employer provided)",
    "salaryMin": 126000,
    "salaryMax": 196000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "datePosted": "3d",
    "jobUrl": "https://www.glassdoor.com/job-listing/example-JV.htm",
    "searchQuery": "software engineer",
    "requestedLocation": "New York, NY",
    "source": "glassdoor",
    "scrapedAt": "2026-06-12T12:00:00.000Z"
}
```

The run also writes `OUTPUT` and `SUMMARY` records to the default key-value store. These include counts, warnings, duplicate skips, charged event counts, backend run IDs, backend dataset IDs, and the dataset URL for quick canary verification.

### Pricing

This actor uses pay per event with predictable billing.

| Event       |                  Price |
| ----------- | ---------------------: |
| Actor start | $0.00005 per run start |
| Job scraped |   $0.012 per saved job |

A 50-job run costs up to about $0.600 in job events plus the small start event. The actor logs the maximum cost before scraping and keeps a dedicated charge counter so it cannot bill more job events than `maxResults`.

### Reliability Notes

Glassdoor is protected and can return security pages, empty responses, or rate limits to direct browser runs. During build canaries, direct local and direct cloud requests were blocked, so this actor uses the internal `khadinakbar/jobs-scraper` Glassdoor backend and normalizes its output into a dedicated Glassdoor jobs schema.

- User input issues finish with a warning instead of a failed run.
- Backend run IDs and dataset IDs are written into `OUTPUT` and `SUMMARY`.
- Partial results are saved before warnings are reported.
- Duplicate jobs are skipped by default using job ID, URL, or a title-company-location hash.
- If the backend fails, the actor fails loudly instead of pretending an empty dataset is valid.

### API Usage

```bash
apify call khadinakbar/glassdoor-jobs-scraper --input='{
  "searchQuery": "data engineer",
  "location": "Austin, TX",
  "maxResults": 25,
  "daysOld": 7
}'
```

With the Apify API:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/glassdoor-jobs-scraper').call({
    searchQuery: 'product manager',
    location: 'San Francisco, CA',
    maxResults: 50,
});
console.log(run.defaultDatasetId);
```

### MCP And AI Agents

The actor is MCP optimized. Field names are flat, descriptions are semantic, and every row keeps source links so an agent can cite or inspect the originating page. Use it when Claude, ChatGPT, or another agent needs current job listings with salary text, company names, locations, and URLs.

Tool routing summary: scrape Glassdoor jobs for recruiting, salary benchmarking, labor-market research, and hiring-signal workflows. Do not use for reviews, interviews, or private account data. Returns one row per job with job, company, salary, location, date, and source URL. Charged $0.012 per job returned plus a $0.00005 start event.

### Legal And Compliance

Use this actor responsibly and only for use cases where you have a lawful basis to process the data. Review Glassdoor's terms, robots guidance, and applicable laws before running large jobs or redistributing output. The actor is designed for public job-listing research and does not bypass login-only content.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this when you want Glassdoor jobs matching a role, skill, or company. Accepts plain text such as "software engineer", "nurse practitioner", or "data analyst". Defaults to "software engineer" for small health-check runs. This is not a company reviews, interview, or salary-only search.

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

Use this when you need jobs near a city, state, country, or remote-style location label. Accepted examples include "New York, NY", "San Francisco, CA", "London", or "Remote". Defaults to "New York, NY" for predictable canaries. This is not a postal address or radius field.

## `country` (type: `string`):

Use this to label the requested country in output records and summaries. Use a two-letter code such as "US", "GB", "CA", or "AU". Defaults to "US". Search targeting is primarily controlled by the location text.

## `maxResults` (type: `integer`):

Use this to cap how many job records and billable job-scraped events can be returned. Accepts 1 to 1000, with default 50. The actor stops charging and pushing data at this number. This is not a page count.

## `daysOld` (type: `integer`):

Use this when you only want recent Glassdoor jobs. Accepts 1 to 30, for example 7 for jobs posted in the last week. Leave empty to let the backend return its default date range. This is not a timestamp or exact date.

## `includeNoSalaryJobs` (type: `boolean`):

Use this when jobs without visible salary ranges are still useful. Defaults to true because many Glassdoor listings omit pay. Set false for compensation-only datasets. This does not estimate missing salary values.

## `deduplicate` (type: `boolean`):

Use this to skip repeated Glassdoor jobs returned by the backend. Defaults to true and dedupes by job ID, URL, or a title-company-location hash. Set false only when you need raw backend-level evidence. This does not merge with old datasets from previous runs.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "country": "US",
  "maxResults": 50,
  "daysOld": 7,
  "includeNoSalaryJobs": true,
  "deduplicate": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `output` (type: `string`):

No description

# 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 = {
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/glassdoor-jobs-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 = {
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/glassdoor-jobs-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 '{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "country": "US"
}' |
apify call khadinakbar/glassdoor-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glassdoor Jobs Scraper",
        "description": "Scrape Glassdoor job listings with title, company, location, salary, posted date, rating, apply URL, and source URL. MCP optimized for recruiters and job-market research.",
        "version": "1.0",
        "x-build-id": "HIq0ltA4Kxmk1Scej"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~glassdoor-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-glassdoor-jobs-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/khadinakbar~glassdoor-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-glassdoor-jobs-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/khadinakbar~glassdoor-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-glassdoor-jobs-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",
                "properties": {
                    "searchQuery": {
                        "title": "Job search query",
                        "type": "string",
                        "description": "Use this when you want Glassdoor jobs matching a role, skill, or company. Accepts plain text such as \"software engineer\", \"nurse practitioner\", or \"data analyst\". Defaults to \"software engineer\" for small health-check runs. This is not a company reviews, interview, or salary-only search.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Job location",
                        "type": "string",
                        "description": "Use this when you need jobs near a city, state, country, or remote-style location label. Accepted examples include \"New York, NY\", \"San Francisco, CA\", \"London\", or \"Remote\". Defaults to \"New York, NY\" for predictable canaries. This is not a postal address or radius field.",
                        "default": "New York, NY"
                    },
                    "country": {
                        "title": "Requested country",
                        "type": "string",
                        "description": "Use this to label the requested country in output records and summaries. Use a two-letter code such as \"US\", \"GB\", \"CA\", or \"AU\". Defaults to \"US\". Search targeting is primarily controlled by the location text.",
                        "default": "US"
                    },
                    "maxResults": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Use this to cap how many job records and billable job-scraped events can be returned. Accepts 1 to 1000, with default 50. The actor stops charging and pushing data at this number. This is not a page count.",
                        "default": 50
                    },
                    "daysOld": {
                        "title": "Posted within days",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Use this when you only want recent Glassdoor jobs. Accepts 1 to 30, for example 7 for jobs posted in the last week. Leave empty to let the backend return its default date range. This is not a timestamp or exact date."
                    },
                    "includeNoSalaryJobs": {
                        "title": "Include jobs without salary",
                        "type": "boolean",
                        "description": "Use this when jobs without visible salary ranges are still useful. Defaults to true because many Glassdoor listings omit pay. Set false for compensation-only datasets. This does not estimate missing salary values.",
                        "default": true
                    },
                    "deduplicate": {
                        "title": "Remove duplicates",
                        "type": "boolean",
                        "description": "Use this to skip repeated Glassdoor jobs returned by the backend. Defaults to true and dedupes by job ID, URL, or a title-company-location hash. Set false only when you need raw backend-level evidence. This does not merge with old datasets from previous runs.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
