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

Google Jobs scraper: search any job title and location, get title, company, salary, type, full description and apply links as JSON/CSV. 10 jobs per query. AI-built, maintained by Argon AI.

- **URL**: https://apify.com/argon-ai/google-jobs-scraper.md
- **Developed by:** [Argon AI](https://apify.com/argon-ai) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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

Search Google Jobs and get structured job listings: title, company, location, posted date, salary, job type, full description, qualification/responsibility highlights and apply links. You send search queries (and optionally a location); the actor returns up to 10 jobs per query.

Built by an AI and maintained by Argon AI. It is a small, single-purpose tool; read "Limits" before you rely on it.

### What it does

For each query the actor loads the Google Jobs results for `<query> jobs in <location>` through Apify's Google SERP proxy and parses the 10 jobs on the page. There is no browser, so runs are light (256 MB) and cheap. Queries run five at a time, and a query that fails or comes back empty is retried.

### Input

| Field | Type | Meaning | Example |
|---|---|---|---|
| `queries` (required) | list of strings | Each one is searched separately | `["data analyst", "nurse"]` |
| `location` | string | City or region; the search becomes `<query> jobs in <location>`. Empty means no location | `"London"` |
| `countryCode` | string | Google `gl` country, localises results | `"gb"` |
| `languageCode` | string | Google `hl` language. Use `en`: posted date and job type are only parsed from English text | `"en"` |
| `expandQueries` | boolean | Also search each query with remote, senior, full time, contract and part time added, to get past the 10-per-query cap. Duplicates are removed before saving | `false` |
| `maxResults` | integer 1-10 | Jobs kept per query. 10 is the most Google gives | `10` |
| `maxRetries` | integer 0-10 | Retries for a search that fails or returns no jobs | `3` |

```json
{ "queries": ["software engineer", "product manager"], "location": "London", "countryCode": "gb", "languageCode": "en" }
```

### Output

One dataset item per job.

| Field | Description |
|---|---|
| `title` | Job title |
| `company` | Employer name |
| `location` | Job location as Google shows it |
| `via` | Board Google lists as the source (e.g. LinkedIn, Indeed) |
| `posted` | e.g. "3 days ago"; null when not shown or not parsed |
| `salary` | Salary text when Google shows one (about half of jobs in our test) |
| `jobType` | Full-time, Part-time, Contractor, Internship or Temporary, when shown |
| `description` | Full job description text |
| `highlights` | Qualifications / Responsibilities / Benefits lists, when shown (seen on US results) |
| `applyLinks` | List of `{source, url}`; about 5 per job on average |
| `googleUrl` | Link to the job on Google |
| `query`, `searchLocation` | The search that produced the job |

Real item from a test run (long fields shortened with "..."):

```json
{
  "title": "Graduate Group Data Analyst",
  "company": "Agility",
  "location": "Manchester",
  "via": "reed.co.uk",
  "posted": "17 hours ago",
  "salary": "£27k–£30k a year",
  "jobType": null,
  "description": "I'm partnered with a PLC organisation who have an exciting opportunity to join their analytics team as a Group Data Analyst.\n\nThis is an ideal opportunity for someone with a numeric/analytical backgro ...",
  "highlights": null,
  "applyLinks": [
    {
      "source": "reed.co.uk",
      "url": "https://www.google.com/goto?url=CAESywEB6zswFaiGyYd-7xTQk4CTz49RgWNznP4GE6Zlv7BbaFgwD0VDHS..."
    },
    {
      "source": "BeBee",
      "url": "https://www.google.com/goto?url=CAES6AEB6zswFQaMi9Bjp5vMqxFKTMACneQsc521SZhg-bbpK73SqvngDB..."
    }
  ],
  "googleUrl": "https://www.google.com/search?ibp=htl;jobs&q=data+analyst+jobs+in+Manchester&hti...",
  "query": "data analyst",
  "searchLocation": "Manchester"
}
```

### Limits (please read)

- **10 jobs per query.** There is no paging. To collect more, turn on `expandQueries` (about 60% of each variant's jobs are new in a test of one query) or send many queries: title variants, nearby cities, many locations.
- **English only** for `posted` and `jobType`. Other languages may leave them empty.
- `jobType` was found on 95 of 100 US jobs but only 17 of 100 UK jobs in our test; the UK labels are probably missed by the parser.
- Apply links are Google redirect links (`google.com/goto?url=...`) that lead to the employer or job board; they are not resolved.
- Google can change its page markup at any time. When that happens the actor returns no jobs until it is updated. When a page parses to zero jobs the actor stores a sample as `EMPTY_<n>` in the key-value store.
- Duplicates across queries are possible and are not removed (199 unique of 200 in our test).
- Test size is small: 20 queries, all returned 10 jobs on the first attempt. That is not a guarantee about long-run failure rates.
- Scraping Google may conflict with Google's terms. Use the data responsibly and check what applies to you.

### Pricing

Pay per result: **$3 per 1,000 jobs** (one dataset item is one result). You pay for results only; the actor's proxy and compute are included. Queries that return nothing produce no results and no charge.

### Output tabs

The dataset has an Overview table (title, company, location, posted, salary, type, via, query) and the full JSON.

# Actor input Schema

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

One job search per line, e.g. "data analyst" or "registered nurse". Each query is searched separately and returns up to 10 jobs. Send many specific queries (title variants) to collect more.

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

City or region added to every query as "<query> jobs in <location>", e.g. "London" or "Austin, TX". Leave empty to search without a location.

## `countryCode` (type: `string`):

Two-letter Google country code (gl) used to localise results, e.g. us, gb, in, de.

## `languageCode` (type: `string`):

Two-letter Google interface language (hl). Keep en: posted date and job type are only parsed from English text.

## `maxResults` (type: `integer`):

Maximum jobs kept per query (1-10). Google gives 10 per search and the actor cannot page further.

## `maxRetries` (type: `integer`):

How many times to retry a search that fails or returns no jobs (0-10).

## `expandQueries` (type: `boolean`):

Also search each query with the words remote, senior, full time, contract and part time added (6 searches per query instead of 1). Gives roughly 60% new jobs per variant; duplicates are removed before saving, so you are not charged for them.

## Actor input object example

```json
{
  "queries": [
    "software engineer",
    "product manager"
  ],
  "location": "London",
  "countryCode": "us",
  "languageCode": "en",
  "maxResults": 10,
  "maxRetries": 3,
  "expandQueries": false
}
```

# Actor output Schema

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

All scraped jobs: title, company, location, posted date, salary, job type, description, highlights and apply links.

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

Per-query counts of attempts, blocks, errors and jobs saved.

# 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",
        "product manager"
    ],
    "location": "London"
};

// Run the Actor and wait for it to finish
const run = await client.actor("argon-ai/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",
        "product manager",
    ],
    "location": "London",
}

# Run the Actor and wait for it to finish
run = client.actor("argon-ai/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",
    "product manager"
  ],
  "location": "London"
}' |
apify call argon-ai/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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