# Glassdoor Jobs Scraper: Past the 30-Page Limit, With Salaries (`alexmorain/glassdoor-jobs-scraper`) Actor

Scrape Glassdoor job listings beyond the ~560 jobs one search returns: searches are split by employer size, seniority, job type, salary and posting date, with salary estimates, skills, employer ratings and optional full job pages. New-jobs-only monitoring with a webhook.

- **URL**: https://apify.com/alexmorain/glassdoor-jobs-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 jobs

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Glassdoor Jobs Scraper: past the 30-page limit, with salaries

Scrape Glassdoor job listings for any keyword and location, with the salary estimate, skills, employer rating and, if you want, the full job page and employer profile. One Glassdoor search stops at 30 pages, about 560 unique jobs, even when it announces thousands. This Actor notices when a search hits that limit, cuts it into smaller searches with Glassdoor's own filters, and merges the results without duplicates.

- **Up to 4 times more jobs per search**: 2,320 unique jobs for "software engineer" in New York, where the plain search returns 559 (Glassdoor announces 3,675).
- **Salary on 86 to 98 % of jobs**: low, median and high estimate, currency and period, from the search results alone.
- **No account, no cookies, no browser**: Glassdoor's own JSON, read over residential proxies.
- **Counted against Glassdoor's numbers**: each search reports what Glassdoor announces and what was retrieved.
- **New jobs only**: schedule it daily, get only the jobs you have not received yet, with a webhook at the end.

### What does Glassdoor Jobs Scraper do?

You give it keywords and locations, or Glassdoor search URLs copied from your browser. It returns one row per job:

- the job: title, normalized title, occupation, location, posting date, Easy Apply, sponsored flag, job page and apply link;
- the pay: salary min, median and max, currency, period (annual, hourly...) and whether the employer provided it;
- what Glassdoor extracted: skills and other attributes (benefits, schedule, education);
- the employer: name, Glassdoor id, overall rating, logo.

With **Full job pages** on, each row also gets the full description (HTML and plain text), job types, education, years of experience, city, state, postal code and coordinates, and the employer's size, revenue, type, industry, headquarters, website, founding year, CEO, ratings by category, CEO approval, benefits rating and review highlights.

It works on glassdoor.com, glassdoor.co.uk, glassdoor.fr and glassdoor.de.

### Why scrape Glassdoor jobs?

- **Recruiting and sourcing**: see who hires for a role in a city, at what pay, with which skills.
- **Salary benchmarks**: pay ranges by title, city, seniority and employer size, with the employer's own figure flagged.
- **Sales prospecting**: companies that hire are companies that spend. Filter by employer size and rating, then reach out.
- **Labor market research**: demand for a skill over time, remote share, Easy Apply share, posting volumes.
- **Job alerts and job boards**: feed your own board or Slack channel with new jobs every morning.

### Why one Glassdoor search is not enough

Glassdoor shows 30 jobs per page and stops at page 30. Pages also repeat jobs from one page to the next, so a search returns about 560 unique jobs whatever its total, and nothing on the page says so. Measured on 17 November 2026:

| Search | Glassdoor announces | Plain search returns | This Actor |
|---|---|---|---|
| software engineer, New York | 3,675 | 559 | 2,320 |
| data analyst, Chicago | 303 | 287 | 287 (no limit hit) |
| nurse, United States | 478,353 | 600 | split by city to go further |

When a search reaches page 30, the Actor reads it again cut by employer size, then by seniority, job type, salary band (glassdoor.com) and posting date, cutting each part further while it still hits the limit. Parts that still hit it are also read in the opposite date order, which reaches the other end of the list. Every job is delivered once per run.

Glassdoor's announced total runs about 15 % above what even a complete read returns, so expect retrieved below announced. The log and the SEARCHES record show both numbers for every search.

### How to scrape Glassdoor jobs

1. Open the Actor and type one or more **Keywords**, such as `software engineer`.
2. Add **Locations**: a city (`New York, NY`), a state (`Texas`), a country (`United States`), or leave empty to search the whole country of the site.
3. Pick filters if you want them: date posted, remote, Easy Apply, job type, seniority, employer size, salary, radius.
4. Set **Max jobs**, your cost cap. Press **Start**.

The log says which Glassdoor place each location was matched to, how many jobs Glassdoor announces for each search and how many were retrieved.

### Input examples

New software engineering jobs of the last week in two cities, with full job pages:

```json
{
  "keywords": ["software engineer", "data engineer"],
  "locations": ["New York, NY", "Austin, TX"],
  "postedWithin": "7",
  "includeDetails": true,
  "maxItems": 2000
}
```

A search copied from Glassdoor, filters included:

```json
{
  "startUrls": ["https://www.glassdoor.com/Job/new-york-ny-software-engineer-jobs-SRCH_IL.0,11_IC1132348_KO12,29.htm?fromAge=3"],
  "maxItems": 500
}
```

Remote product manager jobs at well rated large employers, with a salary:

```json
{
  "keywords": ["product manager"],
  "locations": ["United States"],
  "remoteOnly": true,
  "employerSizes": ["5"],
  "minEmployerRating": "4",
  "salaryOnly": true,
  "maxItems": 1000
}
```

Daily job alert:

```json
{
  "keywords": ["nurse practitioner"],
  "locations": ["Texas"],
  "newOnly": true,
  "maxItems": 0,
  "webhookUrl": "https://hooks.slack.com/services/..."
}
```

### Input reference

| Field | What it does |
|---|---|
| `keywords` | Job titles or keywords. Each is searched in each location. |
| `locations` | Cities, states or countries, matched to Glassdoor places. Empty = the whole country of the site. |
| `startUrls` | Glassdoor job search URLs; the filters in the URL are kept. |
| `site` | glassdoor.com, glassdoor.co.uk, glassdoor.fr or glassdoor.de. |
| `includeDetails` | Read each job's own page (charged as a job with details). |
| `maxItems` | Stop after this many jobs in total. 0 = no limit. Default 1,000. |
| `maxItemsPerSearch` | Stop each search after this many jobs. 0 = no limit. |
| `splitSearches` | Go past the 30-page limit (on by default). |
| `sortBy` | `date` (newest first, default) or `relevance`. |
| `postedWithin` | `any`, `1`, `3`, `7`, `14` or `30` days. |
| `remoteOnly`, `easyApplyOnly` | Glassdoor's remote and Easy Apply filters. |
| `jobTypes` | fulltime, parttime, contract, permanent, temporary. |
| `seniority` | internship, entrylevel, midseniorlevel, director, executive. |
| `employerSizes` | Glassdoor's five employer size bands: 1 tiny, 2 small, 3 medium, 4 large, 5 huge. |
| `minSalary` | glassdoor.com only, in steps of 20,000 USD from 70,000. |
| `radius` | Miles around each location: 0, 5, 10, 15, 25, 50, 100. |
| `companyIds` | Glassdoor employer ids or employer URLs. |
| `minEmployerRating` | Keep employers rated at least this (applied by the Actor, not charged). |
| `salaryOnly` | Keep jobs with a pay estimate (applied by the Actor, not charged). |
| `newOnly`, `registryKey` | Monitoring: only jobs not delivered before. |
| `webhookUrl` | JSON summary when the run ends. |

Several values in `jobTypes`, `seniority`, `employerSizes` or `companyIds` run one search per value, because Glassdoor takes one value per filter; results are merged without duplicates. A run takes up to 200 searches (keywords × locations × filter values).

#### Details that need a word

- **Employer rating filter**: Glassdoor's own minimum rating filter lets lower rated employers through (an employer at 3.2 passes a 4.0 filter). This Actor filters on the rating shown with each job instead, so the result is exact. Jobs left out are not charged.
- **Posting date**: `postedDate` is the run date minus Glassdoor's `ageInDays`. With full job pages, `discoverDate` gives the date Glassdoor first saw the job.
- **Salary**: `salarySource` says whether the employer gave the pay (`EMPLOYER_PROVIDED`) or Glassdoor estimated it (`ESTIMATED`). Salary bands can mix hourly and annual pay; check `salaryPeriod`.

### What data can it extract? Every output field

| Field | Description |
|---|---|
| `jobId` | Glassdoor job listing id, use it to deduplicate |
| `title`, `normalizedTitle`, `occupation` | Job title as written, as normalized by Glassdoor, and occupation |
| `employerName`, `employerId`, `employerRating`, `employerLogoUrl` | Employer |
| `location`, `locationId`, `locationType`, `countryId` | Where the job is |
| `ageInDays`, `postedDate` | When it was listed |
| `easyApply`, `isSponsored` | Apply on Glassdoor, sponsored listing |
| `salaryMin`, `salaryMedian`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salarySource` | Pay |
| `descriptionSnippet` | Extract shown in search results |
| `skills`, `jobAttributes` | What Glassdoor extracted from the job |
| `url`, `applyUrl` | Job page and apply link |
| `site`, `searchKeyword`, `searchLocation`, `searchUrl`, `scrapedAt` | Which search found it, and when |
| `hasDetails` | True when the full job page was read |
| `description`, `descriptionText` | Full description, HTML and plain text |
| `discoverDate`, `jobTypes`, `education`, `yearsOfExperience`, `remoteWorkTypes` | Job page details |
| `city`, `state`, `country`, `postalCode`, `latitude`, `longitude` | Exact place |
| `employerSize`, `employerRevenue`, `employerType`, `employerIndustry`, `employerHeadquarters`, `employerWebsite`, `employerFounded`, `ceoName` | Employer profile |
| `ratings`, `ceoApprovalRating`, `benefitsRating`, `benefitsReviewCount`, `employerReviewCount`, `reviewHighlights`, `employerReviewsUrl` | Employer ratings and reviews |

Every row has every field; a field Glassdoor does not give is `null` (or an empty list). The fields from `description` on are filled with **Full job pages** only.

### Example output

```json
{
  "jobId": 1010210034088,
  "title": "Software Engineer",
  "normalizedTitle": "Software Engineer",
  "occupation": "software developer",
  "employerName": "Acme Corp",
  "employerId": 1043893,
  "employerRating": 3.7,
  "location": "Manhattan",
  "locationType": "city",
  "ageInDays": 3,
  "postedDate": "2026-11-14",
  "easyApply": false,
  "salaryCurrency": "USD",
  "salaryPeriod": "ANNUAL",
  "salaryMin": 125000,
  "salaryMedian": 137500,
  "salaryMax": 150000,
  "salarySource": "EMPLOYER_PROVIDED",
  "skills": ["Software engineering", "Database systems", "CSS"],
  "url": "https://www.glassdoor.com/job-listing/...",
  "site": "glassdoor.com",
  "searchKeyword": "software engineer",
  "searchLocation": "New York, NY",
  "hasDetails": false
}
```

### The SEARCHES record

The run's key-value store holds a `SEARCHES` record, one entry per search: keyword, location and Glassdoor place id, filters, URL, jobs announced by Glassdoor, unique jobs retrieved and delivered, sub-searches and pages read, sub-searches still at the limit, failures, whether the read was complete, and Glassdoor's filter counts (`facets`) for the search. Locations Glassdoor does not know appear there with an error.

### Monitor new Glassdoor jobs: New jobs only mode

Turn on **New jobs only** and schedule the Actor. It remembers the jobs it delivered for these exact searches and filters, and the next run returns only jobs it has not delivered before. After one complete run, the next runs read only the days since then (Glassdoor's date filter), which makes daily runs fast and cheap. Jobs already delivered are never charged again. A run stopped early (job limit, charge limit) is not counted as complete, so nothing is skipped.

Use **Monitoring key** to keep several independent watches on the same searches.

#### Webhook at the end of the run

Set `webhookUrl` and the Actor posts a JSON summary when it ends:

```json
{
  "actor": "glassdoor-jobs-scraper",
  "runId": "...",
  "datasetId": "...",
  "mode": "new-only",
  "status": "succeeded",
  "searches": 2,
  "failedSearches": 0,
  "jobs": 37,
  "jobsWithDetails": 0,
  "skippedAlreadySeen": 412,
  "chargeLimitReached": false
}
```

### Export Glassdoor jobs to CSV, Excel or JSON

Open the run's **Storage** tab and export the dataset as CSV, Excel, JSON, XML or HTML. The **Jobs** view shows the main fields; **All fields** has everything.

### Using the Glassdoor jobs API from your code

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alexmorain/glassdoor-jobs-scraper").call(run_input={
    "keywords": ["data analyst"],
    "locations": ["Chicago"],
    "maxItems": 500,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["employerName"], job["salaryMedian"])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('alexmorain/glassdoor-jobs-scraper').call({
    keywords: ['data analyst'],
    locations: ['Chicago'],
    maxItems: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~glassdoor-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["data analyst"], "locations": ["Chicago"], "maxItems": 100}'
```

### Integrations

Connect the Actor to Make, Zapier, n8n, Google Sheets, Slack, Airtable or your own webhook from the **Integrations** tab, or schedule it from **Schedules**.

### Glassdoor Jobs Scraper pricing

Pay per result, no monthly fee:

| Event | Price |
|---|---|
| Actor start | $0.002 per GB of memory (512 MB by default: $0.001) |
| Job | $1.00 per 1,000 jobs |
| Job with details (full job pages) | $2.00 per 1,000 jobs |

Higher Apify plans pay less per job. Jobs left out by your rating or salary filter, duplicates across sub-searches, and jobs already delivered in monitoring mode are never charged. **Max jobs** is your cost cap; you can also set a maximum charge per run.

### Limits and what this Actor does not do

- Very broad searches (nurse in the United States, 478,353 announced) cannot be read in one run: add locations or narrower keywords. The log names searches that still hit the limit after splitting.
- Retrieved stays below announced: Glassdoor's total includes jobs it does not serve, about 15 % even on complete reads.
- Salary bands for splitting exist on glassdoor.com only; other sites split by the other filters.
- No reviews, salaries or interview pages: use [Glassdoor Reviews Scraper](https://apify.com/alexmorain/glassdoor-reviews-scraper) for reviews.
- Jobs only, no account features (saved jobs, applications).

### FAQ

#### How do I scrape Glassdoor jobs?

Type a keyword and a location, press Start. Or paste a Glassdoor search URL. No account needed.

#### Is it legal to scrape Glassdoor jobs?

Job listings are public pages. This Actor reads only what any visitor sees, without logging in. Follow Glassdoor's terms and the laws that apply to you, and do not use the data to harm the people or companies in it.

#### Does it need a Glassdoor account or login?

No. It reads Glassdoor's public job search without an account or cookies.

#### Why do I get fewer jobs than Glassdoor announces?

Glassdoor's total runs about 15 % above what it serves, even when every page is read. And above ~560 jobs, a plain search cannot go further; this Actor splits the search to get past that, and the log shows announced and retrieved for every search.

#### Can I scrape Glassdoor jobs in the UK, France or Germany?

Yes: set `site` to glassdoor.co.uk, glassdoor.fr or glassdoor.de, or paste a search URL from those sites.

#### Does it get salaries?

Yes, from the search results: low, median and high, currency, period, and whether the employer provided them. Glassdoor gives a salary on 86 to 98 % of jobs in our tests.

#### How do I get only the new jobs?

Turn on **New jobs only** and schedule the Actor daily. Each run returns jobs not delivered before, and reads only the days since the last complete run.

#### How much does it cost to scrape Glassdoor jobs?

$1 per 1,000 jobs, $2 per 1,000 with full job pages, plus a fraction of a cent per run. See pricing above.

### A word on personal data

Job listings describe companies and roles, not private people. Full job pages can name a CEO or a recruiter. Use the data for a defined purpose and follow the data protection rules that apply to you.

### Support

Something not working, or a field you need? Open an issue in the Issues tab of the Actor.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Glassdoor Jobs Scraper page](https://alexis.morain.fr/en/scrapers/glassdoor-jobs-scraper/) of my site. The [Job boards family page](https://alexis.morain.fr/en/scrapers/families/jobs/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

## `keywords` (type: `array`):

Job titles or keywords, one per line, as you would type them in Glassdoor's search box. Each keyword is searched in each location below.

## `locations` (type: `array`):

Cities, states or countries, one per line, such as <code>New York, NY</code>, <code>Texas</code>, <code>London</code> or <code>United States</code>. Each name is matched to a Glassdoor place, and the run log says which one. Empty = the whole country of the selected site (United States on glassdoor.com).

## `startUrls` (type: `array`):

Or paste Glassdoor job search URLs, one per line, copied from your browser after a search, such as <code>https://www.glassdoor.com/Job/new-york-ny-software-engineer-jobs-SRCH_IL.0,11_IC1132348_KO12,29.htm?fromAge=3</code>. The filters in the URL (date posted, job type, seniority, salary, employer size, radius, company, industry) are kept. Can be combined with keywords.

## `site` (type: `string`):

Which Glassdoor site the keywords are searched on. Pasted URLs keep their own site.

## `includeDetails` (type: `boolean`):

Also read each job's own page: full description (HTML and plain text), job types, education, years of experience, exact place and coordinates, and the employer's size, revenue, industry, headquarters, website, CEO, ratings by category and review highlights. Charged as a job with details.

## `maxItems` (type: `integer`):

Stops after this many jobs, all searches together. Each job is one charged result, so this is also your cost cap. <b>0 = no limit</b>.

## `maxItemsPerSearch` (type: `integer`):

Stops each search (one keyword in one location) after this many jobs, so one large search does not use the whole budget. <b>0 = no limit</b>.

## `splitSearches` (type: `boolean`):

A Glassdoor search stops at 30 pages, about 560 unique jobs, whatever it announces. When a search reaches that limit, the actor cuts it by employer size, seniority, job type, salary and posting date, and reads each part. Turn off to read only what Glassdoor's own pages show.

## `sortBy` (type: `string`):

Order in which jobs are read. With a job limit, most recent first returns the newest jobs.

## `postedWithin` (type: `string`):

Keep only jobs posted within this period, as Glassdoor's date filter does.

## `remoteOnly` (type: `boolean`):

Keep only jobs Glassdoor marks as remote.

## `easyApplyOnly` (type: `boolean`):

Keep only jobs you can apply to on Glassdoor directly.

## `jobTypes` (type: `array`):

Empty = every job type. Several values are read as one search each and merged without duplicates.

## `seniority` (type: `array`):

Empty = every level. Several values are read as one search each and merged without duplicates.

## `employerSizes` (type: `array`):

Glassdoor's five employer size bands, from tiny to huge. Empty = every size. Several values are read as one search each and merged without duplicates.

## `minSalary` (type: `integer`):

glassdoor.com only. Keep jobs whose pay estimate reaches this amount. Glassdoor filters by steps of 20,000 from 70,000, the value is rounded down to a step.

## `radius` (type: `string`):

Distance around each location. Empty = Glassdoor's default. Needs a location.

## `companyIds` (type: `array`):

Keep only jobs of these employers: Glassdoor employer ids such as <code>9079</code>, or employer URLs such as <code>https://www.glassdoor.com/Overview/Working-at-Google-EI_IE9079.htm</code>. One search each.

## `minEmployerRating` (type: `string`):

Keep only jobs from employers rated at least this on Glassdoor, from 1 to 5, such as <code>3.5</code>. Applied by the actor on the rating shown with each job, so it is exact; jobs left out are not charged.

## `salaryOnly` (type: `boolean`):

Keep only jobs that come with a pay estimate. Jobs left out are not charged.

## `newOnly` (type: `boolean`):

Remembers which jobs it already delivered for these exact searches and filters, and returns only the new ones on the next run, reading only the days since the last complete run. Jobs already delivered are not charged again. Schedule it daily or weekly.

## `registryKey` (type: `string`):

Name your monitoring memory to keep several independent watches on the same searches. Empty = one memory per distinct set of searches and filters.

## `webhookUrl` (type: `string`):

Receives a JSON summary (status, jobs, run id, dataset id) when the run ends. Slack, Discord, Zapier and Make URLs work. Never logged.

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

Glassdoor blocks datacenter and direct connections, so the actor uses Apify residential proxies in the US and changes IP by itself when one is refused. Leave as is.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "site": "glassdoor.com",
  "includeDetails": false,
  "maxItems": 50,
  "maxItemsPerSearch": 0,
  "splitSearches": true,
  "sortBy": "date",
  "postedWithin": "any",
  "remoteOnly": false,
  "easyApplyOnly": false,
  "salaryOnly": false,
  "newOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

One row per job, main fields

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

Every job with all fields

## `searches` (type: `string`):

Per search: jobs announced by Glassdoor, unique jobs retrieved and delivered, sub-searches and pages read, wall hits, and Glassdoor's filter counts

# 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 = {
    "keywords": [
        "software engineer"
    ],
    "locations": [
        "New York, NY"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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 = {
    "keywords": ["software engineer"],
    "locations": ["New York, NY"],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/glassdoor-jobs-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call alexmorain/glassdoor-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/glassdoor-jobs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/9i03AsdLIa5pXWnSD/builds/mD4C43gTfgp9ZIzZH/openapi.json
