# Google Jobs Scraper — Salaries, Descriptions & Apply Links (`genial_candlestand/google-jobs-scraper`) Actor

Get Google Jobs listings by search term and location: job title, company, full description, parsed salary, posted date, remote flag and all apply links with real URLs. Many terms per run, any Google market, no login. $4.25 per 1,000 jobs.

- **URL**: https://apify.com/genial_candlestand/google-jobs-scraper.md
- **Developed by:** [Flowo](https://apify.com/genial_candlestand) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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/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 Scraper — Salaries, Descriptions & Apply Links

This actor searches Google Jobs for one or many job search terms and returns one row per unique job: `title`, `companyName`, `location`, the full `description`, parsed salary (`salaryMin`, `salaryMax`, `currency`, `salaryPeriod`), `publishedAt` and every apply option with its real target URL in `applyOptions`. No login or API key is needed.

You can set a location, a Google market and language, a posted-date filter, a job type and a remote-only switch. Results are ready for spreadsheets, job boards, salary research or AI agents.

### What does it do?

You give the actor a list of job search terms (for example "registered nurse" or "data analyst") and, optionally, a location such as "Chicago, IL". It runs each term as a Google Jobs search, pages through the results and returns the details Google shows for each job: company, location, the job board it came from (`via`), description, highlights (qualifications, benefits, responsibilities), job type, tags, salary and posted date.

Each job appears once per run, even if several search terms find it. It is built for recruiters and sourcers, job-market analysts, HR-tech and job-board builders, salary researchers, and AI agents that answer "find me X jobs in Y".

### How to use

1. Open the actor in Apify Console and click **Try for free**.
2. Enter one or more **Job search terms**, one per line.
3. Add a **Location** (strongly recommended) and, if needed, a **Country** and **Language**.
4. Optionally set **Date posted**, **Job type**, **Remote jobs only** and the limits.
5. Click **Start**, then download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

AI agents can call the actor through the Apify API or Apify MCP with the same JSON input.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Job listing (one unique job saved to the dataset) | $0.00425 (= **$4.25 per 1,000 jobs**) |
| Actor start | $0.00005 (Apify's standard start price) |

Higher Apify plans get lower per-job prices: Bronze $3.825, Silver $3.40 and Gold and above $2.975 per 1,000 jobs. Duplicate jobs, searches without results and runs with invalid input are not charged.

Example: the default input (2 terms × up to 50 jobs) returns up to 100 jobs and costs about $0.43 on the free plan. Set **Max jobs in total** to cap the spend.

### Input

| Field | Meaning |
|---|---|
| `queries` (required) | Job search terms, one per line. Each term is a separate search. |
| `location` | City, region or country added to every term, e.g. "New York, NY". |
| `country` | Two-letter Google market code (default `us`), e.g. `gb`, `de`, `in`, `jp`. |
| `language` | Label language (default `en`), e.g. `de`, `fr`, `pt-BR`. |
| `datePosted` | `any`, `today` (last 24 hours), `3days`, `week` or `month`. Works in every country and language. |
| `employmentType` | `any`, `fullTime`, `partTime`, `contract` or `internship`. Works in every country and language; one type per run. |
| `remoteOnly` | Only remote jobs (default false). Available in the US, UK, India, Germany and Brazil; elsewhere the run stops with an input error. |
| `maxItemsPerQuery` | Max unique jobs per term, 1–500 (default 50). |
| `maxItems` | Max jobs in the whole run (default 1000). |
| `proxyConfiguration` | A proxy is required; the default Apify datacenter proxy works best. |

Example input:

```json
{
  "queries": ["data analyst", "data engineer"],
  "location": "Bangalore",
  "country": "in",
  "datePosted": "week",
  "maxItemsPerQuery": 100
}
```

### Output

Each dataset row is one job.

| Field | Description |
|---|---|
| `id`, `url` | Google's job id and a Google Jobs link that opens the job |
| `title`, `companyName`, `location`, `via` | Basic job data and the board Google took it from |
| `description`, `descriptionIsPreview` | Description text; `true` when Google only shows a preview |
| `employmentType`, `isRemote`, `tags` | Job type, remote flag, benefit and other chips |
| `salaryText`, `salaryMin`, `salaryMax`, `currency`, `salaryPeriod` | Salary as shown and parsed |
| `publishedAtText`, `publishedAt` | Posted date as shown and as an approximate ISO date |
| `highlights` | Sections such as Qualifications, Benefits, Responsibilities |
| `applyOptions`, `applyUrl` | All apply links with real target URLs; the first one |
| `imageUrl` | Company logo |
| `query`, `position`, `page`, `country`, `language`, `scrapedAt` | Search context |

Real example (description and lists shortened):

```json
{
  "id": "_QNkGauliwHHe4OMAAAAAA==",
  "title": "Software Engineer (Mid-Level)",
  "companyName": "Brean Capital, LLC",
  "location": "New York, NY",
  "via": "Indeed",
  "description": "Software Engineer (Mid-Level)\n\nCompany: Brean Capital, LLC\n...",
  "descriptionIsPreview": false,
  "employmentType": "Full-time",
  "isRemote": false,
  "salaryText": "110K–130K a year",
  "salaryMin": 110000,
  "salaryMax": 130000,
  "currency": "USD",
  "salaryPeriod": "year",
  "publishedAtText": "2 days ago",
  "publishedAt": "2026-10-22",
  "tags": ["No degree mentioned", "Health insurance", "Dental insurance"],
  "highlights": [{ "title": "Qualifications", "items": ["Core Technical Stack: 3+ years of professional experience working with C# and ASP"] }],
  "applyOptions": [
    { "title": "Apply directly on Indeed", "url": "https://www.indeed.com/viewjob?jk=2f463a74d9025996&utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic" }
  ],
  "query": "software engineer",
  "position": 1,
  "page": 1,
  "country": "US",
  "language": "en"
}
```

### Use cases

- **Recruiting and sourcing:** watch openings for a role in a city, with company, description and apply links.
- **Job-market analysis:** compare demand for several roles in one market in a single run, each job counted once.
- **Salary research:** collect pay with parsed min, max, currency and period, for example hourly pay for part-time roles.
- **Daily monitoring:** schedule a run with `datePosted: 3days` (or `today`), `remoteOnly` and a job type to catch fresh remote listings.
- **Non-English markets:** search with local terms, e.g. "Krankenpfleger" in Berlin with `country: de`, `language: de`, `employmentType: partTime` and `datePosted: week`.
- **Job boards and AI agents:** feed aggregated listings or answer "jobs for X in Y" requests.

### Limitations

- Google returns about 10 jobs per page and usually ends a broad search after roughly 100–150 jobs; narrow searches end earlier.
- Salary, highlights, tags and the posted date are filled only when Google shows them. Salary is most common in the US; highlights were not seen in Germany, Japan, the UK or India.
- In some markets (for example Germany) Google shows only a description preview; `descriptionIsPreview` is then `true`.
- Labels such as `employmentType`, `publishedAtText` and highlight titles follow the chosen `language`. `publishedAt` is approximate.
- Without a location, Google picks jobs near the proxy IP, often a random US city.
- Narrow filter combinations (for example part-time + remote + last 7 days for a niche role) can legitimately return no jobs.
- Markets where Google has no Jobs search (for example `cn`) return no results and a warning.
- A proxy is required. Residential proxies are blocked by Google more often than the default datacenter proxy.
- A job found by several terms is saved only for the first term that found it.
- Google can change its pages; if the layout changes, the actor stops with an error instead of returning wrong data.

### Filters

- **Date posted** uses Google's `after:` date operator, so it works the same in every country and language (tested in the US, UK, Canada, Germany, France, Spain, Brazil and Japan). The actor also drops jobs whose posted age is known and older than the window.
- **Last 24 hours** (`today`) finds few jobs, because Google lists few jobs that fresh; use `3days` for broader monitoring.
- **Job type** uses the phrase Google itself shows in the market's language (for example `Teilzeit`, `temps partiel`, `パートタイム`).
- **Remote jobs only** needs a market where Google offers a Remote filter (US, UK, India, Germany, Brazil) and a Language of that market (e.g. `de` for Germany). In Canada, France, Spain, Japan, Italy and Mexico, or with a different language, the run stops at once with a clear input error instead of returning nothing.
- If the filters together leave no jobs, the run succeeds with 0 rows and a warning that names the filters.

### FAQ

**Is it legal to scrape Google Jobs?**
The actor collects job postings that Google shows publicly, without logging in. You are responsible for how you use the data and for complying with applicable laws and the terms of the sites involved. Listings can contain contact details a company chose to publish; handle them according to data-protection rules.

**Which countries work?**
Any Google market that has the Jobs search. Date and job type filters were tested in the US, UK, Canada, India, Germany, Switzerland, France, Spain, Brazil, Japan and Italy. The remote filter works only where Google offers it (see Filters).

**Why is `location` recommended?**
Google builds the results from the search text. A location in the input is added to each term.

**What happens when nothing is found?**
The run succeeds with no rows and no charge, with a warning for each such term.

**Can I search many terms at once?**
Yes. List them in `queries`; they share the location and filters.

### Other actors

Other public data actors from the same author:

- [Google Trends Scraper](https://apify.com/genial_candlestand/google-trends-scraper) — interest over time, by region and related queries for search terms.
- [Google Ads Transparency Scraper](https://apify.com/genial_candlestand/google-ads-transparency-scraper) — ads run by a domain or advertiser.
- [Google Play Reviews Scraper](https://apify.com/genial_candlestand/google-play-reviews-scraper) — app reviews with ratings and developer replies.

# Actor input Schema

## `queries` (type: `array`):

Jobs to search for, one term per line, e.g. "registered nurse" or "data analyst". Each term is a separate search; duplicates and empty lines are ignored. At least one term is required.

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

City, region or country added to every term, e.g. "Chicago, IL" or "Berlin". Strongly recommended: without it Google picks jobs near the proxy IP, often a random US city.

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

Two-letter ISO country code of the Google market (Google's gl parameter), e.g. us, gb, de, fr, in, jp, br. It sets the market and labels; where the jobs are comes from Location. "uk" is accepted as gb. Markets where Google has no Jobs search (e.g. cn) return no results with a warning.

## `language` (type: `string`):

Language of Google's labels (Google's hl parameter): two-letter ISO 639-1 code, optionally with a region, e.g. en, de, fr, ja, pt-BR. It changes texts such as "3 days ago", "Full-time" and highlight titles, not the job descriptions. Any language works with any Country for searching, Date posted and Job type. "Remote jobs only" needs a language of the market (e.g. de for Germany, en for India).

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

Only jobs posted within the last 1, 3, 7 or 30 days. Works in every country and language (Google's after: date operator, plus a check of each job's posted date). "Last 24 hours" finds few jobs: Google lists few jobs that fresh. "any" = no date filter.

## `employmentType` (type: `string`):

Only jobs of this type, using Google's own Job type filter in the market's language (e.g. Teilzeit, temps partiel, パートタイム). Works in every country and language. "any" = all types. One type per run.

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

Only remote / work-from-home jobs, using Google's Remote filter. Google offers it only in some markets: tested US, UK and India (English), Germany (German) and Brazil (Portuguese). Not available in Canada, France, Spain, Japan, Italy or Mexico, or with a Language that is not the market's: the run then stops at once with an input error. Other markets are checked on the first request. Can be combined with Location, Date posted and Job type.

## `maxItemsPerQuery` (type: `integer`):

Stop each term after this many unique jobs (1–500). Google usually has up to 100–150 jobs for a broad search; narrow searches end earlier.

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

Stop the whole run after this many jobs across all search terms (each job is charged once).

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

A proxy is required: Google blocks requests without one. Apify datacenter proxy (the default) works best; residential proxy is blocked more often by Google and is slower.

## Actor input object example

```json
{
  "queries": [
    "software engineer",
    "data analyst"
  ],
  "location": "New York, NY",
  "country": "us",
  "language": "en",
  "datePosted": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "maxItemsPerQuery": 50,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all scraped jobs

## `overview` (type: `string`):

Jobs in the overview table 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 = {
    "queries": [
        "software engineer",
        "data analyst"
    ],
    "location": "New York, NY"
};

// Run the Actor and wait for it to finish
const run = await client.actor("genial_candlestand/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 = {
    "queries": [
        "software engineer",
        "data analyst",
    ],
    "location": "New York, NY",
}

# Run the Actor and wait for it to finish
run = client.actor("genial_candlestand/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 '{
  "queries": [
    "software engineer",
    "data analyst"
  ],
  "location": "New York, NY"
}' |
apify call genial_candlestand/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,genial_candlestand/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/ZddIRUpqlky1VNbD8/builds/8B0CsdKa8gCc8zPLj/openapi.json