# Google Jobs Scraper API: Salary & Direct Apply Links (`farside/google-jobs-scraper`) Actor

Returns Google Jobs listings for search queries: title, company, location, postedAt, salary (parsed min/max/currency), direct apply links with source platform, description. Reliable schema for recruiters, market research and AI agents. Pay per result.

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

## Pricing

from $2.00 / 1,000 google jobs listing results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Jobs Scraper — a stable Google Jobs API for recruiters, researchers & AI agents

Turn any job search into clean, structured data: give this actor a query like
*"registered nurse jobs in dallas"* and it returns the jobs Google surfaces as
tidy records — title, company, location, posting date, salary, and **direct
apply links with the source platform** — ready for your ATS, spreadsheet, or
agent pipeline.

Built for one thing the popular Google Jobs actors are rated poorly for:
**a reliable, stable schema you can depend on.**

### What you get

- **Clean, normalized records.** Salary parsed into `salaryMin` / `salaryMax` /
  `salaryCurrency` / `salaryType` (e.g. `$40K–$43K a year` → `40000`, `43000`,
  `USD`, `year`), posting age turned into an ISO `postedAt` date, employment
  type, and a full job description.
- **Direct apply links, de-Googled.** Every listing's real apply URLs (employer
  ATS, LinkedIn, Indeed, ZipRecruiter, Greenhouse, Lever, Workday, …) — not
  Google redirect links — each tagged with the `platform` and `domain` where we
  can identify it.
- **Multiple queries per run**, optional `location`, `countryCode`, and a
  `postedWithinDays` freshness filter that maps to Google's own "Date posted"
  windows.
- **A stable, documented output schema** with dataset views (overview, salary,
  apply links, full) and a run-report record so you always know what happened.
- **Pay-per-result pricing**: you're charged per job record, nothing else.

### Input

```json
{
  "queries": [
    "registered nurse jobs in dallas",
    "software engineer jobs in seattle"
  ],
  "location": "",
  "countryCode": "us",
  "maxResultsPerQuery": 50,
  "postedWithinDays": 7
}
```

Only `queries` is required. Write queries the way you'd type them into Google.
`postedWithinDays` accepts 1, 3, 7 or 31 (it rounds up to Google's nearest
window). The default proxy is Apify's **Unblocker** group — see *Limitations*.

### A sample record

Real record from a live capture (`chef jobs in seattle`, 2026-09-03) — every
field exactly as Google served it:

```json
{
  "jobId": "LQVJsKheF836EEshAAAAAA==",
  "title": "Full-Time Sous Chef — Culinary Leader in Seattle",
  "company": "Wolfgang Puck Catering",
  "location": "Seattle, WA",
  "via": "JobLeads",
  "postedAt": "2026-08-21",
  "postedRelative": "13 days ago",
  "employmentType": "Full-time",
  "salaryMin": 40000,
  "salaryMax": 43000,
  "salaryCurrency": "USD",
  "salaryType": "year",
  "salaryRaw": "$40K–$43K a year",
  "descriptionSnippet": "Wolfgang Puck Catering in Seattle is hiring immediately for a full-time Sous Chef to lead kitchen operations, supervise cooks and food-service staff, and ensure recipe and production standards are met.\nThe role is based at 2122 7th Avenue, Seattle, WA 98121 with schedule Monday through Friday (hours",
  "applyLinks": [
    { "url": "https://www.jobleads.com/us/job/full-time-sous-chef-culinary-leader-in-seattle--seattle--e056edee599e22a704dcc79c7e4aae156?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic", "platform": "JobLeads", "domain": "jobleads.com" },
    { "url": "https://jooble.org/jdp/-7824064096309794040?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic", "platform": "Jooble", "domain": "jooble.org" }
  ],
  "query": "chef jobs in seattle",
  "capturedAt": "2026-09-03T07:04:47Z"
}
```

The dataset also ends with a single **run-report** record (`isRunReport: true`)
summarizing counts, per-query outcomes, and whether a time or budget limit was
hit.

### Typical uses

- **Recruiters** monitoring who's hiring for a role in a market, with apply
  links already resolved to the real ATS.
- **Market & labor researchers** pulling salary and employer data across roles
  and cities.
- **AI agents** that need a dependable jobs-data endpoint with a schema that
  doesn't shift under them.

### For AI agents (MCP)

This actor is **MCP-ready and pay-per-event**: agents calling it through
`mcp.apify.com` (Claude, Cursor, VS Code, ChatGPT) pay per result record via
Apify prepaid credit or x402/USDC — no monthly plan.

- **Input**: `queries` (string array, required), optional `location`,
  `countryCode`, `maxResultsPerQuery`, `postedWithinDays`.
- **Output**: flat records with stable names and types — `jobId`, `title`,
  `company`, `location`, `postedAt`, `salaryMin` / `salaryMax` /
  `salaryCurrency` / `salaryType`, `applyLinks[]`, `descriptionSnippet`,
  `query`, `capturedAt` — plus a final `isRunReport` record.
- **Reliability**: the schema is versioned and documented, and every run
  self-stops cleanly inside its time budget — no hung agent calls.

### Limitations (read these)

Honesty first — this is a scraper of a surface Google actively protects:

- **Anti-bot is an arms race.** This actor reads the public Google Jobs surface
  (`google.com`, no login, no captcha-solving). Google changes its layout and
  defenses; when it does, output can degrade until the parser is updated (see
  MAINTENANCE.md). We design so one field breaking never breaks the whole run.
- **Salary and apply links appear on only *some* listings.** Google shows a
  salary on roughly a third of jobs and apply links on most but not all. When a
  field isn't shown, it's `null` — we never invent it. "Completeness" here means
  *relative to what Google displays* (measured at 100% of shown fields in
  testing), not that every field is filled on every job.
- **Results per query.** With the default **Unblocker** proxy (which reliably
  gets past Google's bot wall in the cloud), each query returns the **top page
  of results Google serves (~10–15 of the most relevant jobs)** — deep, clean,
  and dependable. To pull deeper result sets you can switch
  `proxyConfiguration` to the **Residential** group, which supports full
  pagination up to `maxResultsPerQuery`, but is more likely to be throttled by
  Google. For breadth, prefer several focused queries over one broad one.
- **A supported proxy is required in the cloud.** Google blocks datacenter IPs;
  the run needs an Apify plan that includes the Unblocker (default) or
  Residential proxy group.
- **Memory.** Minimum 1024 MB. If you switch to the **Residential** group for
  deep pagination, give the run at least 2048 MB — that path launches a
  browser to mint the session, which needs the headroom.

### Keywords

Google Jobs, Google Jobs API, jobs API, job listings scraper, job search API,
Google for Jobs, recruiting data, salary data, apply links, ATS leads,
MCP, AI agents, agent tool, job listings API.

# Actor input Schema

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

One or more job searches, run independently. Write them the way you would type them into Google, e.g. "python developer jobs in austin". You can bake the location into the query or use the separate 'location' field. Up to 20 queries per run.

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

Optional location appended to every query as " in <location>", e.g. "Austin, TX". Skip it if your queries already name a location.

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

Two-letter country code for Google's 'gl' parameter (which Google edition to search). Defaults to 'us'.

## `maxResultsPerQuery` (type: `integer`):

Upper bound on unique jobs per query. Note: with the default Unblocker proxy each query returns roughly Google's first page (~10-15 top results); the Residential proxy paginates deeper toward this cap but is more often throttled. Hard cap 500.

## `postedWithinDays` (type: `integer`):

Only return jobs posted within this many days. Maps to Google's own 'Date posted' windows (1=yesterday, 3=last 3 days, 7=last week, 31=last month), rounding up to the nearest one. Leave empty for no date filter.

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

Proxy settings. Defaults to Apify's Unblocker group, which handles Google's anti-bot for the jobs surface and is strongly recommended. Residential works but Google captchas it more often on the jobs search. Requires an Apify plan with the chosen proxy group.

## Actor input object example

```json
{
  "queries": [
    "software engineer jobs in new york",
    "registered nurse jobs in dallas"
  ],
  "location": "Austin, TX",
  "countryCode": "us",
  "maxResultsPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

One record per job listing, plus a final run-report record (isRunReport: true).

# 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 jobs in new york"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("farside/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 jobs in new york"] }

# Run the Actor and wait for it to finish
run = client.actor("farside/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 jobs in new york"
  ]
}' |
apify call farside/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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