# Google Jobs Scraper - Descriptions, Apply Links & Salary (`datalume/google-jobs-scraper`) Actor

Scrape Google Jobs for any job title and location in 100+ countries. Every job includes the full description, real apply URLs (employer site, LinkedIn, Indeed), salary, job type, posted date and highlights. From $1.70 per 1,000 jobs - no charge for empty searches or duplicates.

- **URL**: https://apify.com/datalume/google-jobs-scraper.md
- **Developed by:** [Greg](https://apify.com/datalume) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 2 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 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 - Descriptions, Apply Links & Salaries

Scrape **Google Jobs** (the job listings box in Google Search) for any job title and location. Every job comes with the **full job description**, the **real apply URLs** (company career site, LinkedIn, Indeed …), **salary**, **job type**, **posted date** and Google's **job highlights** - one clean row per unique job.

**From $1.70 per 1,000 jobs.** Descriptions and apply links are included, never an extra charge. You pay only for unique jobs: empty searches, failed pages and duplicates are free.

### Why this Google Jobs scraper

| | |
|---|---|
| **Full description** | The complete job post text (not the short preview), with line breaks kept |
| **Real apply URLs** | Direct links to the employer site and job boards - not Google redirect links. Each link has a `direct` flag and a `titleMatch` check, and `applyUrl` is the best one |
| **More jobs per search** | Google Jobs returns about 10 jobs per request and has no "next page" for automated requests. The Actor repeats your search with Google's own filters and merges the results: **43-55 unique jobs per search** on Standard in our 16 Nov 2026 test |
| **Salary** | Google's salary chip, or the pay sentence from the job highlights when the chip is missing (`salaryText`) |
| **Worldwide** | Any country Google Jobs serves - US, UK, Canada, India, Germany, France, Japan, Singapore, Hong Kong, Taiwan and more, in the local language |
| **Fair pricing** | One price per unique job. Nothing for empty searches, blocked pages or duplicates across your queries |

### Use cases

- **Job boards and aggregators** - feed fresh listings with full descriptions and apply links
- **Recruiting and sales prospecting** - see which companies are hiring for which roles, where
- **Labor-market and salary research** - track demand and pay by title, city and country
- **Job alerts** - schedule a daily run with *Date posted = Past 24 hours* and get only new jobs
- **AI agents and RAG** - structured, deduplicated job data with clean text

### Input

| Field | What it does | Example |
|---|---|---|
| `queries` | Job titles, skills or companies, one per line | `registered nurse`, `data analyst` |
| `locations` | Cities, regions or countries, one per line. Each query is searched in each location | `Houston, TX`, `London` |
| `country` | 2-letter country Google searches from | `us`, `gb`, `de`, `in` |
| `language` | Google's language. Use the local one outside English-speaking countries | `en`, `de`, `ja`, `zh-TW` |
| `datePosted` | Any time, past 24 hours, 3 days, week or month | `today` |
| `employmentType` | Full-time, part-time, contract or internship (English searches) | `fulltime` |
| `remoteOnly` | Remote / work-from-home jobs only (English searches) | `true` |
| `coverage` | Requests per search: Fast (3), Standard (9), Max (13). More requests = more unique jobs. You never pay for requests | `standard` |
| `maxJobsPerSearch` | Stop a search after this many unique jobs | `100` |
| `maxJobs` | Stop the whole run after this many jobs (0 = no limit) | `500` |

#### Example input

```json
{
  "queries": ["registered nurse", "nurse practitioner"],
  "locations": ["Houston, TX", "Dallas, TX"],
  "country": "us",
  "language": "en",
  "datePosted": "week",
  "coverage": "standard",
  "maxJobsPerSearch": 100
}
```

This runs 4 searches (2 queries × 2 locations).

### Output

One row per unique job. Example (shortened):

```json
{
  "title": "Software Engineer, ASE Commerce Engineering",
  "company": "Apple",
  "location": "New York, NY",
  "via": "Indeed",
  "postedAgo": "4 days ago",
  "schedule": "Full-time",
  "salary": "150K-278K a year",
  "salaryText": "150K-278K a year",
  "applyUrl": "https://www.indeed.com/viewjob?jk=4b2a8ac1cec683f2&utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic",
  "applyLinks": [
    {"site": "Indeed", "url": "https://www.indeed.com/viewjob?jk=4b2a8ac1cec683f2&…", "direct": false, "titleMatch": null},
    {"site": "LocalJobs.com", "url": "https://www.localjobs.com/job/new-york-ny-software-engineer-ase-commerce-engineering?…", "direct": false, "titleMatch": true},
    {"site": "Monster", "url": "https://www.monster.com/job-openings/staff-software-engineer-capacity-engineering-new-york-ny--…", "direct": true, "titleMatch": false}
  ],
  "highlights": {
    "Qualifications": ["We are looking for a self-starting, energetic individual who is not afraid to question assumptions …", "…"],
    "Benefits": ["At Apple, base pay is one part of our total compensation package and is determined within a range", "…"],
    "Responsibilities": ["You will work on adding new integrations, scaling current data flows, and re-imagining existing processes …", "…"]
  },
  "description": "Summary\n\nThe Apple Services Engineering Commerce team is one of the most exciting examples of Apple's long-held passion for combining art and technology. …",
  "tags": ["4 days ago", "150K-278K a year", "Full-time", "Dental insurance", "Health insurance"],
  "jobId": "NHBzI3XRZye-1x5IAAAAAA==",
  "googleJobsUrl": "https://www.google.com/search?ibp=htl;jobs&q=software+engineer+New+York,+NY+full+time&htidocid=NHBzI3XRZye-1x5IAAAAAA%3D%3D&…",
  "searchQuery": "software engineer",
  "searchLocation": "New York, NY",
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-11-08T04:23:28+00:00"
}
```

*Real row from a run on 8 Nov 2026 (shortened). The default input above returned 70 unique jobs on 8 Nov and 47-54 on 16 Nov 2026.*

Dataset views: **Overview** (title, company, location, posted, type, salary, apply link) and **Full details** (description, highlights, all apply links). Export as JSON, CSV, Excel or via API.

### Pricing

Pay per unique job, with Apify Store plan discounts:

| Apify plan | Price per 1,000 jobs |
|---|---|
| Free | $2.00 |
| Starter | $1.90 |
| Scale | $1.80 |
| Business | $1.70 |

- Included in the price: full description, all apply links, highlights, salary.
- **Not charged:** searches with no results, pages Google blocked (after retries), and jobs already saved earlier in the same run.
- Example: 10 job titles × 5 cities with Standard coverage ≈ 50 searches × ~45 jobs ≈ 2,250 jobs ≈ **$4.50** on the Free plan.
- Set a maximum cost per run in the run options - the Actor stops cleanly when it is reached (tested 8 Nov 2026: a $0.03 limit saved and charged exactly 15 jobs). `maxJobs` works the same way without touching the run options.

### Reliability (real runs)

Measured on **16 Nov 2026**, US, 5 job searches in Chicago × 9 requests each (45 requests, 9 at a time):

- **39/45 pages loaded**. The other 6 failed after retries and were skipped - not charged.
- **43-55 unique jobs per search** (246 in total).
- 5 searches took 6 minutes; the default input (1 search) took about 1.5 minutes.
- Google sometimes answers with a short results page (2-3 jobs) instead of the full Jobs list. The Actor detects it and asks again; if the full list does not come, it keeps the short page's jobs.
- If a run gets close to its timeout, the Actor stops sending new requests and finishes normally with the jobs it already has.

Earlier test, 8 Nov 2026 (20 searches, 180 requests): **1,546/1,546 parsed jobs** had a full description and a real apply URL.

International check, same day: Germany, Japan, UK, Taiwan, Hong Kong, Singapore, India and France all returned title, company, location, apply URL and description for **10/10 jobs** on the first page.

### Use it from Python, n8n or an AI agent (MCP)

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datalume/google-jobs-scraper").call(run_input={
    "queries": ["registered nurse"],
    "locations": ["Houston, TX"],
    "datePosted": "week",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"], item.get("salary"), item.get("applyUrl"))
```

**n8n, Make, Zapier or any HTTP client:** use the Apify app/node ("Run Actor" → `datalume/google-jobs-scraper`) with the same JSON input, or for short runs call one endpoint that starts the run and returns the results:

```
POST https://api.apify.com/v2/acts/datalume~google-jobs-scraper/run-sync-get-dataset-items
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json
```

**AI agents (Claude, Cursor, VS Code and other MCP clients):** add this Actor as a tool through Apify's hosted MCP server — you sign in to Apify in the browser on first use, no token in the config:

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

AI agents without an Apify account can also run this Actor and pay per run through Apify's agentic payments (x402, Skyfire) - it uses pay-per-event pricing only.

Then just ask in plain language. Example requests and the input that answers them:

| You ask | Input |
|---|---|
| "Remote software engineer jobs posted today in the US" | `queries: ["software engineer"], country: "us", datePosted: "today", remoteOnly: true` |
| "Nurse jobs in Houston with salaries" | `queries: ["registered nurse"], locations: ["Houston, TX"]` |
| "Who is Tesla hiring right now?" | `queries: ["Tesla"], coverage: "max"` |

### Good to know

- **Job highlights** (Qualifications / Benefits / Responsibilities) are shown by Google for **US listings**. Other countries have the full description but usually no highlights.
- **Not available:** Google Jobs does not serve **South Korea** or **mainland China**, so searches there return nothing (and cost nothing).
- **Salary** is filled only when Google shows pay for the job (often 30-60% of US jobs, varies by role and country). `salaryText` may be a sentence such as "Make $60,000 and up!".
- **Posted date** is Google's relative label ("3 days ago", "vor 1 Tag"). Some countries (e.g. India) do not show it.
- **`datePosted` is enforced on our side too.** Google does not apply its date filters strictly (in a test with "last week", 7% of the jobs Google returned were 8-23 days old), so jobs whose posted date is older than your window are dropped - not saved and not charged. Jobs without a posted date are kept.
- **Employment type / remote filters** use Google's English filter phrases. For other languages use `datePosted` and put the job type into your query. Non-English searches use date windows to collect more jobs, typically **~30 unique jobs per search** (e.g. "Krankenpfleger" in Berlin: 30 jobs from 4 requests on 8 Nov 2026) - add more specific queries to get more.
- **Apply links are the buttons Google shows.** Google merges copies of a job from many job boards into one listing, and sometimes merges a different job by mistake (in our tests, a few links per run). Each link has `titleMatch`: `true` when its URL contains the job title, `false` when it clearly names a different job, `null` when the URL is only an ID. Filter out `false` if you need strict links.
- `applyUrl` skips links with `titleMatch = false`, then prefers the employer's own site (link matching the company name), then a title-matching link, then the first link Google lists.
- Jobs are deduplicated by Google's job ID across the whole run. A job found by two of your searches is saved once, with the first search's `searchQuery`.
- Google decides what it shows; results can differ slightly from what you see in your browser (location, personalization).

### FAQ

**How many jobs can I get per search?**
About 40-55 with Standard coverage (16 Nov 2026 test: 43-55 per search). Niche roles return fewer. For more, use Max coverage and split broad searches into several queries or cities (e.g. "nurse" → "ICU nurse", "ER nurse", "travel nurse").

**Why don't you just open page 2, 3, 4?**
Google Jobs has no page 2 for automated requests - more results load only by scrolling inside Google's own app. Repeating the search with Google's filters is the reliable way to reach more of the listings.

**Do I need proxies or a Google account?**
No. Everything runs on Apify; there is nothing to configure.

**Do you collect personal data?**
No. The Actor saves only the public job post as Google shows it. It does not log in anywhere.

**Can I run it every day for new jobs only?**
Yes - schedule it with *Date posted = Past 24 hours*. Use the same queries each day; `jobId` lets you skip jobs you already have.

**Something is missing or wrong?**
Open an issue on the Actor page with your input and run ID - I usually reply within a day.

### Tutorial

[How to Scrape Google Jobs in Python (2026): Full Descriptions and Real Apply Links](https://dev.to/datalume/how-to-scrape-google-jobs-in-python-2026-full-descriptions-and-real-apply-links-2k9d) — why plain requests hit a JavaScript wall, where the real apply URLs hide in the page, and how to get more than 10 jobs per search.

### Feedback

If this Actor saved you time, a short review on the Store page helps others find it. If something is off, please open an issue first so I can fix it.

### More from datalume

Reliable public-data scrapers - verified results, no charge for failures: **[apify.com/datalume](https://apify.com/datalume)**

***

*This Actor is not affiliated with, endorsed by or sponsored by Google. "Google" and "Google Jobs" are trademarks of Google LLC. It collects publicly available job listings only.*

# Actor input Schema

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

What to search on Google Jobs, one per line - a job title, skill or company (e.g. "software engineer", "registered nurse", "data analyst at Google"). Each query is combined with every location below.

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

City, region or country to search in, one per line (e.g. "New York, NY", "London", "Berlin"). Leave empty to search without a location (Google then uses the country below).

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

2-letter country code Google searches from: us, gb, ca, au, in, de, fr, jp, sg, hk, tw … Google Jobs is not available in South Korea or mainland China.

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

Language of Google's interface and labels, e.g. en, de, fr, ja, zh-TW. Use the local language for non-English countries to get local listings.

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

Only jobs posted within this period. "Past 24 hours" is ideal for a daily schedule.

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

Only this type of job (English searches only).

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

Only remote / work-from-home jobs (English searches only).

## `coverage` (type: `string`):

Google Jobs returns about 10 jobs per request and has no next page, so the Actor repeats each search with Google's own filters (full-time, remote, past week …) to collect more jobs. Fast = up to 3 requests per search, Standard = up to 9 (43-55 jobs per search in our 16 Nov 2026 test), Max = up to 13. You pay only for unique jobs, never for requests.

## `maxJobsPerSearch` (type: `integer`):

Stop a search (query × location) after this many unique jobs.

## `maxJobs` (type: `integer`):

Stop the whole run after this many unique jobs. 0 = no limit (the run's maximum cost still applies).

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "country": "us",
  "language": "en",
  "datePosted": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "coverage": "standard",
  "maxJobsPerSearch": 100,
  "maxJobs": 0
}
```

# Actor output Schema

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

One row per job: title, company, location, posted, type, salary, apply link.

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

Descriptions, highlights and every apply link.

## `runStats` (type: `string`):

Searches, requests, empty and failed pages, charged jobs.

# 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"
    ],
    "locations": [
        "New York, NY"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datalume/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"],
    "locations": ["New York, NY"],
}

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

```

## MCP server setup

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