# Google Jobs Vertical: Pay Bands, Highlights & Apply Routes (`xyrelith-data/google-jobs-scraper`) Actor

Search Google's Jobs vertical by keyword, place, country and language. Export parsed salary bands, employer logos, remote and no-degree flags, Google's qualification/responsibility/benefit highlights, and every apply option with its real URL.

- **URL**: https://apify.com/xyrelith-data/google-jobs-scraper.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Google Jobs Vertical: Pay Bands, Highlights & Apply Routes

Search Google's Jobs tab by role, place, country and language, then receive one clean row per listing with the pay band pulled apart, the employer's logo, Google's own qualification/responsibility/benefit lists, and every place the job can be applied to.

Google's Jobs view is an aggregator: a single search can surface the same opening from LinkedIn, Indeed, Glassdoor, ZipRecruiter, a company career site and several smaller boards. This actor turns that view into structured records instead of a page of cards.

### What it does

- Searches the Google Jobs vertical (`udm=8`) with a keyword and one or more places.
- Targets any Google country market (`gl`) and interface language (`hl`).
- Applies Google's filter chips: date posted, job type, remote/work-from-home, no-degree-mentioned, and employer.
- Saves the salary exactly as Google shows it and also parses minimum, maximum, currency and pay period.
- Collects every apply option on the job, including the provider name, the real destination URL, and whether Google marks it as a direct application.
- Splits Google's "Job highlights" into Qualifications, Responsibilities and Benefits lists, including the extra items Google hides behind a "more items" toggle.
- Fans out across Google's own filter slices to go past the roughly ten listings a single Jobs page returns, then de-duplicates by Google's job ID.
- Has a URL mode for feeding in Google Jobs search links or job share links you already have.

### Modes

**Search by keyword + location** — the default. Each query is combined with each location. Leave locations empty to search the whole country selected under Google country. Google needs a place to open the Jobs view, so the country name is used as the location when none is supplied.

**Parse Google Jobs URLs** — paste search links (`...&udm=8...` or `...&ibp=htl;jobs...`) or a job's share link (`...&htidocid=...`). Search links keep their own filters; a share link returns that one listing.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `mode` | dropdown | `search` | Search by keyword, or parse Google Jobs URLs. |
| `searchQueries` | list | – (UI prefill: `software engineer`) | Job titles, skills or phrases. |
| `locations` | list | – (UI prefill: `Austin, TX`) | Cities, regions or countries added as "jobs near ...". |
| `gl` | dropdown | `us` | Google country market. |
| `hl` | dropdown | `auto` (same as country) | Interface language. Keep auto outside English markets; forcing English often returns no jobs. |
| `radiusKm` | number | `0` | Best-effort radius hint in the search phrase. |
| `datePosted` | dropdown | `any` | Past 24 hours, 3 days, week or month. |
| `jobType` | dropdown | `any` | Full-time, part-time, contractor, internship or temporary. |
| `remoteOnly` | boolean | `false` | Keep jobs Google tags as remote/work from home. |
| `noDegreeOnly` | boolean | `false` | Keep jobs with no degree requirement mentioned. |
| `company` | text | empty | Employer name to search and verify. |
| `maxItems` | number | `50` | Row cap across the whole run. |
| `fanOut` | boolean | `true` | Repeat the search across filter slices to exceed ten jobs per query. |
| `maxSearchesPerQuery` | number | `10` | Cap on filter slices per query. |
| `includeDescription` | boolean | `true` | Save the full description. |
| `includeHighlights` | boolean | `true` | Save the three highlight lists. |
| `includeErrorRows` | boolean | `false` | Save a diagnostic row when a search finds no jobs. |
| `onlyNewJobs` | boolean | `false` | Scheduled runs: skip job IDs seen before. |
| `stateName` | text | `default` | Separate seen-jobs memory per alert. |
| `startUrls` | list | empty | Google Jobs URLs used by URL mode. |

### Output

Every row is a job listing. Empty fields are omitted rather than written as `null`. With `includeErrorRows`, a run that finds no jobs at all also saves a diagnostic row with `recordType: "error"` and an `error` reason.

**Identity and context**

- `jobId` — Google's stable job ID (the `htidocid` value).
- `title`, `employerName`, `employerLogoUrl`, `location`, `otherLocationsCount`, `source`.
- `shareLink` — the Google share link for the listing.
- `sourceUrl` — canonical Google URL for the record (the share link, or the search page).
- `position` — order on the page.
- `searchQuery`, `searchLocation`, `searchFilter`, `searchUrl`, `country`, `language`.
- `recordType`, `scrapedAt`.

**Pay and timing**

- `salary` — exactly as Google shows it.
- `salaryMin`, `salaryMax` — parsed numbers.
- `salaryCurrency`, `salaryCurrencyCode`, `salaryPeriod` — symbol, ISO code and hour/day/week/month/year.
- `salarySource` — `tag` when the pay came from Google's salary chip, `description` when it was parsed from a pay sentence in the description.
- `postedAgo` — Google's own age string.
- `postedAt` — computed ISO date.
- `postedDaysAgo` — numeric age.
- `postedAtApproximate` — true when Google says "30+ days ago".

**Work arrangement**

- `remote` — true when Google tags the job remote/work-from-home or the location is Anywhere/Remote.
- `workFromHome` — true specifically for Google's "Work from home" tag.
- `remoteEvidence` — the signals behind the remote flag.
- `employmentType` and `employmentTypes` — as shown, plus a normalised list.
- `benefits` — Google's benefit tag chips.
- `noDegreeMentioned` and `noDegreeTag` — whether no degree requirement is mentioned, and whether Google itself labelled it.

**Description and highlights**

- `description` — full text, with paragraph breaks preserved.
- `descriptionIsPreview` — true when Google only exposes a short preview.
- `jobHighlights` — object with `qualifications`, `responsibilities` and `benefits` lists.

**Apply options**

- `applyLinks` — every option as `{site, url, direct, resolved, titleMatch}`. `resolved` is true when the real destination URL is present; `titleMatch` is `true`/`false` when the URL slug can be checked against the job title, or omitted for ID-only URLs.
- `applyUrl` — the first option Google lists whose URL does not clearly name a different job, otherwise the first option.
- `directApplyUrl` — first option Google marks as "Apply directly on ...".
- `applyOptionsCount` — number of apply options.
- `isNew` — present when `onlyNewJobs` is on.

### How the job cap is handled

Google's Jobs view does not expose numbered pages: asking for page 2 returns no listings. It shows roughly ten jobs per search. To reach more, the actor repeats the same search with Google's own filter phrases (dates, job types, remote, no degree) and merges the results by `jobId`. The base search always runs first; when `maxItems` is ten or less, only the base runs, keeping small jobs cheap. Set `fanOut` to false if you want exactly one request per query.

### Salary parsing

Pay text is parsed, not guessed. `£50,000 - £60,000 per annum` becomes `{salaryMin: 50000, salaryMax: 60000, salaryCurrency: "£", salaryCurrencyCode: "GBP", salaryPeriod: "year"}`. Hourly, daily, weekly, monthly and yearly forms are recognised, along with `K`, `M`, `B`, `+`, `from`, `up to`, and grouped numbers such as `₹12,00,000`. When Google's salary chip is absent, the actor also checks pay sentences in the full description (for example "The pay range is $120,000 - $150,000 a year") before leaving the field empty.

### Apply links

Google's apply buttons point at redirect URLs, but the real destination is already present in the page data. This actor reads those destinations directly, removes Google Jobs attribution parameters, and keeps the provider name, direct-apply flag and a best-effort `titleMatch` check. Some jobs carry links from several boards; all of them are returned, and `applyUrl` skips a link whose slug clearly names a different job.

### Examples

**Software engineer jobs in Austin, last week**

```json
{
  "searchQueries": ["software engineer"],
  "locations": ["Austin, TX"],
  "datePosted": "pastWeek",
  "maxItems": 50
}
```

**Remote nursing contracts in Houston**

```json
{
  "searchQueries": ["registered nurse"],
  "locations": ["Houston, TX"],
  "jobType": "contractor",
  "remoteOnly": true,
  "maxItems": 30
}
```

**UK market, no degree mentioned, top 20**

```json
{
  "searchQueries": ["data analyst"],
  "locations": ["London"],
  "gl": "gb",
  "hl": "en",
  "noDegreeOnly": true,
  "maxItems": 20
}
```

**Parse a saved Google Jobs link**

```json
{
  "mode": "byUrl",
  "startUrls": ["https://www.google.com/search?q=python+developer+jobs+near+Berlin&udm=8&hl=en&gl=de"]
}
```

### Use cases

- Hiring-market dashboards: open roles by title, place, employer and pay band.
- Compensation research: compare advertised ranges across markets.
- Lead lists: find employers hiring for a niche and reach the posting directly.
- Job-alert automation: scheduled runs with `onlyNewJobs` and `stateName`.
- Board attribution: see which boards Google is aggregating for a role.

### FAQ and limits

**Does this need a login or my own proxy?**
No. It runs with no credentials, cookies or proxy configuration from you; the actor selects the right access route itself.

**Why are there about ten jobs from one search?**
That is Google's Jobs view. The actor fans out across Google's filter chips and de-duplicates to find more, and says so in the run log. It never invents a page 2.

**Why do some rows have no salary?**
Many employers do not publish pay. Google only shows a salary when the source provides one; the actor never estimates or invents an amount. It does read a pay sentence from the description when Google has no salary chip.

**Why do some rows have no highlights?**
Google generates highlight blocks mainly for US listings and not for every job. When a block is absent it is omitted.

**Why is the location sometimes "Anywhere"?**
Google uses that label for fully remote listings. It is treated as a remote signal and preserved as shown.

**Does it work in every country?**
It works in the markets where Google's Jobs tab is available. Some countries or queries return Google's standard web results instead of the Jobs view; the actor reports that in the status message. Google Jobs is not available in South Korea or mainland China, and several other markets (for example Australia, New Zealand, Ireland, Poland and the Nordics) return no listings. Use the local language setting (auto) outside English-speaking markets.

**Why does an English search in Germany return nothing?**
Forcing English in a non-English market is a known Google Jobs zero-results behaviour. Leave `hl` on auto so Google uses the market's own language.

**What about the employer logo?**
Google-hosted employer logos are returned when the listing has one. Listings without a logo simply omit the field.

**Is the posted date exact?**
It is computed from the age Google displays, so treat it as an approximation, especially for "30+ days ago".

**Does the actor need a browser?**
No. It reads Google's rendered Jobs page over HTTP, which keeps runs fast and inexpensive.

### Data source

Public Google Jobs search result pages. This actor is independent and is not affiliated with, endorsed by, or sponsored by Google.

# Actor input Schema

## `mode` (type: `string`):

Search Google Jobs, or parse Google Jobs search/share URLs you already have.

## `searchQueries` (type: `array`):

Job titles, skills or phrases. Each query is searched in every location. Example: software engineer, registered nurse, data analyst.

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

Cities, regions or countries added to each search as 'jobs near ...'. Leave empty to search the whole country selected below.

## `gl` (type: `string`):

Country market for the search (Google's gl parameter). Also steers the proxy exit country. Google Jobs is not available in every market.

## `hl` (type: `string`):

Language Google uses for the interface and for Google's own filter labels (hl parameter). Keep 'Same as country' for non-English markets: forcing English there often returns no jobs.

## `radiusKm` (type: `integer`):

Best-effort radius hint appended to the search phrase. Google Jobs has no true radius parameter, so treat it as a hint, not a hard boundary. 0 disables it.

## `datePosted` (type: `string`):

Keep jobs posted in this window. Google renders the age on each card; the actor also checks the computed date before keeping a row.

## `jobType` (type: `string`):

Keep only full-time, part-time, contractor, internship or temporary roles. Rows whose employment type is unknown pass through.

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

Keep jobs Google tags as remote or work from home, or whose location is Anywhere/Remote.

## `noDegreeOnly` (type: `boolean`):

Keep jobs where Google's 'No degree mentioned' tag is present, or whose description names no degree requirement.

## `company` (type: `string`):

Optional employer name. Added to the search and checked against each row's employer.

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

Maximum rows to save across all queries, locations and filter slices.

## `fanOut` (type: `boolean`):

Google shows about 10 jobs per search. When enabled and maxJobs is above 10, the actor repeats the search with Google's filter phrases (date, job type, remote, no degree) and de-duplicates by job ID to go past that cap. Disable for one request per query.

## `maxSearchesPerQuery` (type: `integer`):

Upper bound on the filter slices fetched for each query when fan-out is on. Higher values find more jobs and use more SERP requests.

## `includeDescription` (type: `boolean`):

Save the full job description text. Turn off for a smaller, faster dataset.

## `includeHighlights` (type: `boolean`):

Save Google's Qualifications, Responsibilities and Benefits lists when present.

## `includeErrorRows` (type: `boolean`):

When a run finds no jobs at all, also save one error row per failed search explaining why. Error rows are never mixed into successful job data.

## `onlyNewJobs` (type: `boolean`):

For scheduled runs: skip job IDs seen in earlier runs with the same state name. New rows get isNew: true.

## `stateName` (type: `string`):

Separate seen-jobs memory for each alert. Use one name per saved search.

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

Mode=parse URLs only. Paste Google Jobs search links (udm=8 or ibp=htl;jobs) or job share links. Search links keep their own filters; share links return that one job.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "software engineer"
  ],
  "locations": [
    "Austin, TX"
  ],
  "gl": "us",
  "hl": "auto",
  "radiusKm": 0,
  "datePosted": "any",
  "jobType": "any",
  "remoteOnly": false,
  "noDegreeOnly": false,
  "company": "",
  "maxItems": 3,
  "fanOut": true,
  "maxSearchesPerQuery": 10,
  "includeDescription": true,
  "includeHighlights": true,
  "includeErrorRows": false,
  "onlyNewJobs": false,
  "stateName": "default",
  "startUrls": []
}
```

# Actor output Schema

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

Dataset containing every scraped Google Jobs record.

# 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 = {
    "mode": "search",
    "searchQueries": [
        "software engineer"
    ],
    "locations": [
        "Austin, TX"
    ],
    "gl": "us",
    "hl": "auto",
    "radiusKm": 0,
    "datePosted": "any",
    "jobType": "any",
    "remoteOnly": false,
    "noDegreeOnly": false,
    "company": "",
    "maxItems": 3,
    "fanOut": true,
    "maxSearchesPerQuery": 10,
    "includeDescription": true,
    "includeHighlights": true,
    "includeErrorRows": false,
    "onlyNewJobs": false,
    "stateName": "default",
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/google-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 = {
    "mode": "search",
    "searchQueries": ["software engineer"],
    "locations": ["Austin, TX"],
    "gl": "us",
    "hl": "auto",
    "radiusKm": 0,
    "datePosted": "any",
    "jobType": "any",
    "remoteOnly": False,
    "noDegreeOnly": False,
    "company": "",
    "maxItems": 3,
    "fanOut": True,
    "maxSearchesPerQuery": 10,
    "includeDescription": True,
    "includeHighlights": True,
    "includeErrorRows": False,
    "onlyNewJobs": False,
    "stateName": "default",
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/google-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 '{
  "mode": "search",
  "searchQueries": [
    "software engineer"
  ],
  "locations": [
    "Austin, TX"
  ],
  "gl": "us",
  "hl": "auto",
  "radiusKm": 0,
  "datePosted": "any",
  "jobType": "any",
  "remoteOnly": false,
  "noDegreeOnly": false,
  "company": "",
  "maxItems": 3,
  "fanOut": true,
  "maxSearchesPerQuery": 10,
  "includeDescription": true,
  "includeHighlights": true,
  "includeErrorRows": false,
  "onlyNewJobs": false,
  "stateName": "default",
  "startUrls": []
}' |
apify call xyrelith-data/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/google-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/1KVu62SDP2ElHgmPi/builds/pXTO2nPDAQePTVOZa/openapi.json
