# Google Jobs Scraper: Salaries & Apply Links (`automationnation/google-jobs-scraper`) Actor

Google Jobs scraper and API: full job descriptions, salaries, highlights and resolved apply links (employer site first) for any search and location in 26 countries. Filters for date, job type and remote. Only-new mode for daily job alerts. $2 per 1,000 jobs + $0.03 per search.

- **URL**: https://apify.com/automationnation/google-jobs-scraper.md
- **Developed by:** [Nathan Carter](https://apify.com/automationnation) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## Google Jobs Scraper

**Google Jobs Scraper is an Apify Actor that extracts job listings from Google Jobs (Google for Jobs) for any search and location.** Each listing comes with the full description, parsed salary, highlights and direct apply links, at $2 per 1,000 jobs.

It works as a **Google Jobs API**:

- call it from code
- schedule it for daily job alerts
- let AI agents (Claude, ChatGPT, Cursor) use it through Apify's MCP server

#### Quick facts

- **What you get, one row per job:**
  - title, company, company website, location, remote flag
  - salary (min / max / currency / period, plus yearly)
  - posted date, job type, full description, highlights
  - every apply link (employer's own site first) and Google's job ID
- **Price:** $2 per 1,000 jobs ($1.50 on paid plans) plus $0.03 per search. Apify's free $5 monthly credit covers about 2,000 jobs.
- **Filters:** date posted, employment type and remote only, re-checked on every job.
- **Monitoring:** **Only new jobs** mode returns just the new postings on scheduled runs.
- **26 countries:** United States, United Kingdom, Canada, India, Germany, Switzerland, Spain, Italy, Mexico, Brazil, Argentina, Colombia, Peru, Japan, Hong Kong, Singapore, UAE, Saudi Arabia, Qatar, Egypt, South Africa, Nigeria, Ghana, Philippines, Malaysia and Pakistan. Dates, salaries and job types are parsed in each market's language.
- **Speed:** about a minute for a 100-job search.
- **AI agents:** connect `https://mcp.apify.com?tools=automationnation/google-jobs-scraper` (setup below).
- **Guide and code examples:** <https://retracn.github.io/automationnation-actors/google-jobs-scraper/> · [GitHub](https://github.com/retracn/google-jobs-scraper)

### What does Google Jobs Scraper do?

Google Jobs collects postings from company career sites and job boards (LinkedIn, Indeed, Glassdoor, ZipRecruiter, Greenhouse, Lever, Workday and thousands more) into one search. This Actor runs your searches there and returns structured data:

- **Job title, company, location, remote flag, source** ("via LinkedIn")
- **Full job description.** The whole text, not a snippet.
- **Salary.** As shown (`$176K–$227K a year`) and parsed: `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`.
- **Posted date.** As shown (`3 days ago`) and as an ISO timestamp.
- **Employment type.** As shown and normalised (`FULL_TIME`, `PART_TIME`, `CONTRACTOR`, `INTERN`).
- **Job highlights.** Qualifications, responsibilities and benefits, when Google extracts them.
- **Apply links**, resolved from Google's redirects to the real URLs. `applyUrl` picks the employer's own site when possible.
- **Google job ID.** Stable across runs, so you can track postings over time.

It handles several searches and locations in one run, removes duplicates across searches, and lets you pick a country.

### Who is it for?

- **Recruiters and staffing agencies.** Find every open role for a skill and city, with direct apply links.
- **Job boards and aggregators.** Fill niche boards with fresh, de-duplicated postings and full descriptions.
- **Sales and growth teams.** Use hiring as a buying signal ("who's hiring data engineers in Austin?").
- **Salary and labour-market research.** Get parsed salary ranges by role, company and city.
- **AI agents and automations.** Typed output fields and a fast default run work well through Apify's MCP server, n8n, Make and Zapier.

### Why this Google Jobs scraper?

- **Lower price.** $2 per 1,000 jobs ($1.50 on paid plans) plus $0.03 per search. For searches of 50+ jobs that is cheaper than each of the six most-used Google Jobs Actors, which charge $3–$200 per 1,000.
- **Only new jobs for daily alerts.** Schedule it and get just the postings you haven't seen. None of the six most-used Actors offer this.
- **Employer-first apply link.** Every apply option is resolved to the real posting. `applyUrl` picks the employer's own careers page when Google has one; that was 91% of jobs in a 200-job test.
- **Strict filters.** Job type, remote and date are re-checked on every job, and non-matching jobs are skipped free.
- **Reliable runs.** Blocked searches are retried with fresh residential IPs (up to 11 attempts) and are never charged.
- **Clean data.** Salaries are parsed into numbers (currency inferred when Google omits the symbol). You also get ISO posted dates, normalised job types and Google's stable job IDs.

See the full [comparison of Google Jobs scrapers on Apify](https://retracn.github.io/automationnation-actors/compare/google-jobs-scrapers/) for prices, run success rates and features side by side.

### How to scrape Google Jobs

1. Enter one or more **Job searches**, e.g. `software engineer`, `registered nurse`.
2. Add a **Location** (city or area) and pick the **Country**.
3. Set **Max jobs per search**. Google usually lists 50–300 jobs per search.
4. Optionally filter by **Date posted**, **Employment type** or **Remote jobs only**.
5. Click **Start**, then download the results as JSON, CSV or Excel, or read them through the API.

#### Input example

```json
{
    "queries": ["software engineer", "data analyst"],
    "location": "London",
    "country": "uk",
    "maxJobsPerQuery": 100,
    "datePosted": "week",
    "employmentType": "fulltime",
    "remoteOnly": false,
    "onlyNewJobs": false
}
```

#### Output example

One real job from a run (description and lists shortened):

```json
{
    "title": "Software Engineer, Backend",
    "companyName": "Plaid",
    "location": "New York, NY",
    "isRemote": false,
    "via": "Plaid",
    "postedAgo": null,
    "postedAt": null,
    "employmentType": "Full-time",
    "employmentTypes": [
        "FULL_TIME"
    ],
    "salaryText": "176K–227K a year",
    "salaryMin": 176000,
    "salaryMax": 227000,
    "salaryCurrency": "USD",
    "salaryPeriod": "YEAR",
    "degreeRequirement": null,
    "description": "We believe that the way people interact with their finances will drastically improve in the next few years. We’re dedicated to empowering this transformation by building the tools and experiences that thousands of develo…",
    "qualifications": [
        "2-4 years of software engineering experience (post-internship)",
        "Proven ability to ship reliable systems or features at scale"
    ],
    "responsibilities": [
        "As a Software Engineer, you will design and build the systems that power how millions of people connect to their finances",
        "You will work across the stack, from reliable backend services and APIs to intuitive applications that bring those systems to life"
    ],
    "benefits": [
        "Growth oriented"
    ],
    "highlights": [
        {
            "title": "Qualifications",
            "items": [
                "2-4 years of software engineering experience (post-internship)"
            ]
        },
        {
            "title": "Responsibilities",
            "items": [
                "As a Software Engineer, you will design and build the systems that power how millions of people connect to their finances"
            ]
        }
    ],
    "applyUrl": "https://plaid.com/careers/openings/engineering/new-york-city-office/software-engineer-backend-2/",
    "applyLinks": [
        {
            "title": "Plaid",
            "url": "https://plaid.com/careers/openings/engineering/new-york-city-office/software-engineer-backend-2/",
            "domain": "plaid.com"
        }
    ],
    "jobUrl": "https://www.google.com/search?ibp=htl;jobs&q=software+engineer+jobs+in+New+York&htidocid=RUfn2deFBPpSoOMVAAAAA…",
    "googleJobId": "RUfn2deFBPpSoOMVAAAAAA==",
    "tags": [
        "176K-227K a year",
        "Full-time",
        "Health insurance",
        "Dental insurance"
    ],
    "searchQuery": "software engineer",
    "searchLocation": "New York",
    "country": "us",
    "language": "en",
    "position": 6,
    "isNew": null,
    "scrapedAt": "2026-10-02T18:08:26.130Z"
}
```

#### Output fields

| Field | Description |
|---|---|
| `title`, `companyName`, `location`, `isRemote`, `via` | Job basics; `via` is where Google found the posting |
| `description` | Full job description text |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Salary as shown and parsed (`HOUR`, `DAY`, `WEEK`, `MONTH`, `YEAR`) |
| `salaryYearlyMin`, `salaryYearlyMax` | Salary converted to a yearly amount, so hourly, daily and monthly pay compare |
| `postedAgo`, `postedAt` | Age as shown, plus an estimated ISO timestamp |
| `employmentType`, `employmentTypes` | As shown, plus normalised values |
| `qualifications`, `responsibilities`, `benefits`, `highlights` | Google's job highlights, when available |
| `applyUrl`, `applyLinks` | Best apply link, plus all options as `{title, url, domain}` |
| `companyDomain` | Employer's website, taken from its own apply link |
| `jobUrl`, `googleJobId` | Google Jobs link and Google's stable job ID |
| `degreeRequirement`, `tags` | Extra notes Google shows ("No degree mentioned", benefits tags) |
| `searchQuery`, `searchLocation`, `country`, `language`, `position`, `isNew`, `scrapedAt` | Search context |

The dataset has three views: **Jobs** (overview), **Salaries** and **Descriptions & apply links**. A run summary (jobs per search, skipped searches, why the run stopped) is saved as `OUTPUT` in the key-value store.

### How much does it cost to scrape Google Jobs?

Pay only for results:

| Plan | Per job | Per 1,000 jobs | Per search |
|---|---|---|---|
| Free | $0.002 | **$2.00** | $0.03 |
| Bronze | $0.0018 | $1.80 | $0.028 |
| Silver | $0.0016 | $1.60 | $0.026 |
| Gold and above | $0.0015 | $1.50 | $0.025 |

The small per-search fee covers opening Google for that search. Examples on the Free plan:

| Run | Cost |
|---|---|
| One search returning 100 jobs | **$0.23** |
| Ten searches of 100 jobs | **$2.30** |
| A daily "only new jobs" check that finds 15 new postings | $0.06 |

**You are not charged for:**

- searches Google blocks or that show no jobs
- jobs that are duplicates of another search in the same run
- jobs already returned in earlier runs (Only new jobs mode)
- jobs that don't match your type, remote or date filters

Residential proxies and compute are included. The Apify Free plan's $5 monthly credit covers about 2,000 jobs (in searches of 100). Set a **maximum cost per run** in the run options and the Actor stops cleanly when it is reached.

### Daily job alerts: Only new jobs

Switch on **Only new jobs (for scheduled runs)** and schedule the Actor (Console → Schedules), e.g. every morning. Each run returns only jobs that weren't returned for the same search in your earlier runs. Jobs are remembered for 120 days, and you pay only for the new ones.

Combine it with **Date posted: Since yesterday** for the fastest, cheapest daily feed. Connect a webhook or integration to send new jobs to Slack, Google Sheets, your ATS or your CRM.

### Use cases and example inputs

- **Daily job alerts.** All new remote Python jobs in the US every morning, sent to Slack or Google Sheets with a webhook:
  ```json
  { "queries": ["python developer"], "country": "us", "remoteOnly": true, "datePosted": "today", "onlyNewJobs": true, "maxJobsPerQuery": 200 }
  ```
- **Hiring signals for sales.** Companies in London hiring data engineers, with their websites (`companyDomain`) ready for enrichment:
  ```json
  { "queries": ["data engineer"], "location": "London", "country": "uk", "maxJobsPerQuery": 300 }
  ```
- **Salary benchmarking.** Nursing pay in Chicago. Use the **Salaries** view and `salaryYearlyMin` / `salaryYearlyMax`:
  ```json
  { "queries": ["registered nurse", "nurse practitioner"], "location": "Chicago", "country": "us", "maxJobsPerQuery": 200 }
  ```
- **Job board content.** Fresh listings with full descriptions for a niche board, de-duplicated across searches:
  ```json
  { "queries": ["solar installer", "wind turbine technician"], "country": "us", "datePosted": "week", "maxJobsPerQuery": 300 }
  ```

### Use Google Jobs Scraper with AI agents (MCP)

AI assistants can search Google Jobs live through Apify's MCP server.

**Hosted (Claude, ChatGPT, Cursor and other MCP clients that support remote servers).** Add this server URL and sign in with Apify:

```
https://mcp.apify.com?tools=automationnation/google-jobs-scraper
```

**Local (Claude Desktop or Cursor config):**

```json
{
  "mcpServers": {
    "google-jobs": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "automationnation/google-jobs-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask, for example:

- "Find 50 remote React developer jobs posted this week in the US, with salaries."
- "Which companies in Manchester are hiring accountants? List their websites."
- "Show me every new nursing job in Chicago since yesterday."

### Integrations and API

- **API:**
  ```bash
  curl -X POST "https://api.apify.com/v2/acts/automationnation~google-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"queries":["nurse"],"location":"Chicago","country":"us","maxJobsPerQuery":20}'
  ```
- **Python / JavaScript:** use the `apify-client` package with Actor ID `automationnation/google-jobs-scraper`.
- **AI agents (MCP):** add the Actor to Apify's MCP server (`https://mcp.apify.com`) and ask, for example, "find remote data engineer jobs posted this week".
- **n8n, Make, Zapier, Google Sheets, Slack, webhooks:** through Apify's integrations.

### FAQ

**Is there an official Google Jobs API?**
No. Google doesn't offer a public API for Google Jobs search results; Google Cloud Talent Solution only searches your own job postings. This Actor gives you Google Jobs data through Apify's REST API, the Python and JavaScript clients, integrations and MCP.

**What's the best Google Jobs scraper?**
It depends on what you need. This Actor is built for complete, clean data at the lowest price among the most-used Google Jobs Actors:

- full descriptions, parsed salaries and the employer's own apply link
- strict filters
- new-only monitoring
- blocked searches are never charged

**How does it compare with SerpApi's Google Jobs API?**
SerpApi sells its Google Jobs API as a monthly subscription. Its free tier is 250 searches a month, and paid plans start at $25 a month for 1,000 searches (checked October 2026). This Actor is pay-per-result with no subscription. It also adds:

- an "Only new jobs" mode for alerts
- a yearly salary equivalent and a company website field
- Apify schedules, integrations and MCP access for AI agents

**Can I scrape Google Jobs for free?**
Yes, within Apify's free plan. Its $5 monthly credit covers about 2,000 jobs with this Actor, with no credit card needed.

**Is it legal to scrape Google Jobs?**
The Actor collects publicly listed job postings. They are business information published by employers and job boards. It does not collect applicant data or log in to anything. You are responsible for how you use the data. Respect Google's terms, the original sites' terms and the laws that apply to you (e.g. GDPR when a posting names a recruiter).

**Which countries are supported?**
Verified in 26 countries: **United States, United Kingdom, Canada, India, Germany, Switzerland, Spain, Italy, Mexico, Brazil, Argentina, Colombia, Peru, Japan, Hong Kong, Singapore, UAE, Saudi Arabia, Qatar, Egypt, South Africa, Nigeria, Ghana, Philippines, Malaysia and Pakistan**. Every one returned Google Jobs listings in live tests, and local-language dates, salaries (€, R$, ¥, pesos and more) and job types are parsed. Google doesn't offer Google Jobs in Australia, New Zealand, Austria, the Netherlands, Portugal or most other European countries.

**How many jobs can I get per search?**
Google usually lists 50–300 jobs per search. For more coverage, run several specific searches ("frontend developer", "React developer") or several locations. Duplicates across searches are removed for free.

**Why is the salary or posted date empty for some jobs?**
Google shows a salary only when the posting includes one, and some postings have no date. Job highlights appear only when Google extracts them from the posting.

**Why does a search take 20–60 seconds?**
The Actor opens Google like a person (search first, then the Jobs view) through residential IPs and retries with fresh IPs when Google blocks a request. That is slower than a raw request but makes runs reliable, and blocked attempts are never charged.

**Do I need my own proxies?**
No. Residential proxies are included. You can switch to your own proxies under **Advanced**.

### More from AutomationNation

- **[Google Trends Scraper & API](https://apify.com/automationnation/google-trends-scraper)**: Google Trends interest over time, by region and city, rising related queries for any number of keywords, plus Trending now searches with news, at $1 per 1,000 keyword reports.
- **[AEO & GEO Tracker: Google AI Overview Citation Checker](https://apify.com/automationnation/aeo-auditor)**: see whether Google AI Overviews cite your website, who is cited instead and what changed since last week.
- **[Google Maps Leads Scraper UK: Emails & Directors](https://apify.com/automationnation/uk-business-leads)**: UK business leads from Google Maps with emails, phone numbers, Companies House directors and AI outreach copy.
- **[App Store & Google Play Reviews Scraper + AI](https://apify.com/automationnation/app-store-review-miner)**: App Store and Google Play reviews turned into an AI report of bugs, feature requests and critical issues.
- **[UK Companies House Leads: Filing Signals & AI Outreach](https://apify.com/automationnation/companies-house-leads)**: newly incorporated UK companies and filing signals straight from Companies House, with AI outreach.
- **[Contact Waterfall Enrichment: Emails & Directors](https://apify.com/automationnation/contact-waterfall-enrichment)**: enrich a list of companies or domains with emails and directors from several sources.

Feedback or a missing field? Open an issue on the Actor's **Issues** tab. Fixes usually ship within a day.

# Changelog

This Actor's version history is a separate document: https://apify.com/automationnation/google-jobs-scraper/changelog.md

# Actor input Schema

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

What to search for, one search per line, e.g. "software engineer", "registered nurse", "marketing manager". Each search runs separately and jobs found by several searches are returned once.

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

City, region or area to search in, e.g. "New York", "London", "Austin, TX". Leave empty to search the whole country selected below.

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

Google country to search in. All listed countries were verified to return Google Jobs listings. Google Jobs is not offered in Australia, New Zealand, Austria, the Netherlands, Portugal and most of Europe.

## `maxJobsPerQuery` (type: `integer`):

Stop each search after this many jobs. Google usually lists 50–300 jobs per search; you are charged only for jobs returned.

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

Only jobs posted within this period.

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

Only jobs of this type.

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

Only remote / work-from-home jobs.

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

Return only jobs this Actor hasn't returned for the same search in your earlier runs (remembered for 120 days). Schedule the Actor daily to get a feed of new postings — you pay only for the new jobs.

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

Optional Google interface language code, e.g. "en", "pt", "es". Leave empty to use the country's main language.

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

Google blocks datacenter IPs, so residential proxies are used by default. Change only if you know you need to.

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "location": "New York",
  "country": "us",
  "maxJobsPerQuery": 10,
  "datePosted": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "onlyNewJobs": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per job.

## `salaries` (type: `string`):

No description

## `details` (type: `string`):

No description

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

Per-search counts, skipped searches and why the run stopped.

# 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"
    ],
    "location": "New York",
    "country": "us",
    "maxJobsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automationnation/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"],
    "location": "New York",
    "country": "us",
    "maxJobsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automationnation/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"
  ],
  "location": "New York",
  "country": "us",
  "maxJobsPerQuery": 10
}' |
apify call automationnation/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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