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

Scrape Google Jobs listings for any search and location: title, company, location, salary, posting date, employment type, benefits, qualifications, full description and direct apply links from every job board. Fast, no browser, pay only for results.

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

## Pricing

$2.00 / 1,000 job listings

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

Get job listings from Google Jobs for any search and place: title, company, location, salary, posting
date, employment type, benefits, Google's "job highlights" (qualifications, responsibilities, benefits),
the **full job description**, and **apply links to every job board** that lists the job (LinkedIn, Indeed,
ZipRecruiter, the employer's own careers page...). No browser, no login, results in seconds.

### What you get for each job

| Field | Example |
|---|---|
| `title`, `company`, `location`, `via` | "Senior Software Engineer", "Jiffy.com", "Austin, TX", "LinkedIn" |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryPeriod` | "$195K–$265K a year", 195000, 265000, "year" (when Google shows a salary) |
| `postedAgo`, `postedAt` | "1 day ago", 2026-10-01T22:00:00+00:00 (estimate) |
| `employmentType`, `benefits` | "Full-time", \["Health insurance", "Dental insurance"] |
| `qualifications`, `responsibilities`, `benefitsHighlights` | Google's extracted highlights, as lists |
| `description` | The complete job description text with paragraph breaks |
| `applyLinks` | Every board's apply link, with `source` and `isDirect` (employer/ATS site) flags |
| `applyUrl` | The best link to apply: the direct employer link if there is one |
| `companyLogo`, `googleJobsUrl`, `id` | Logo image, the listing on Google, Google's job id |

### How to use

1. Enter one or more **search queries** - anything you would type into Google Jobs: `software engineer`,
   `registered nurse in Austin, TX`, `marketing manager remote`.
2. Optionally set a **location** that is added to every query (or a list of **locations** - every query
   runs once per place), a **date posted** window, **remote only**, and an **employment type** (full-time,
   part-time, contractor, internship). Narrow further with **only jobs with a salary** and **exclude
   companies** (e.g. staffing agencies). Jobs filtered out are skipped and **not charged**.
3. Set **maximum jobs per query**. Google shows about 10 jobs per page; to go beyond that the scraper
   automatically runs related searches (Google's own refinement suggestions, posting-date windows and job
   types), deduplicating by job id until your maximum is reached or the results dry up.

Leave **Resolve apply links** on to get the real job-board URLs; turn it off for the fastest runs with
Google redirect links instead.

#### Example input

```json
{
  "queries": ["data analyst", "data engineer"],
  "locations": ["Chicago, IL", "Austin, TX"],
  "datePosted": "week",
  "employmentType": "fulltime",
  "salaryOnly": true,
  "excludeCompanies": ["Robert Half", "Insight Global"],
  "maxResultsPerQuery": 100
}
```

#### Example output

```json
{
  "searchQuery": "data analyst",
  "searchLocation": "Chicago, IL",
  "title": "Data Analyst II",
  "company": "Example Health",
  "location": "Chicago, IL",
  "via": "Indeed",
  "employmentType": "Full-time",
  "postedAgo": "2 days ago",
  "postedAt": "2026-09-30T14:00:00+00:00",
  "salaryText": "$75K–$90K a year",
  "salaryMin": 75000,
  "salaryMax": 90000,
  "salaryPeriod": "year",
  "benefits": ["Health insurance", "Paid time off"],
  "qualifications": ["3+ years of SQL experience", "..."],
  "responsibilities": ["Build dashboards for clinical teams", "..."],
  "description": "Example Health is looking for a Data Analyst II to ...",
  "applyLinks": [
    {"source": "Indeed", "isDirect": false, "url": "https://www.indeed.com/viewjob?jk=..."},
    {"source": "Example Health careers", "isDirect": true, "url": "https://careers.example.com/jobs/123"}
  ],
  "applyUrl": "https://careers.example.com/jobs/123",
  "googleJobsUrl": "https://www.google.com/search?ibp=htl;jobs&q=data+analyst+jobs+in+Chicago,+IL&htidocid=..."
}
```

### Pricing

You pay a small fee per job returned (see the Pricing tab) and nothing else: platform usage and proxy
costs are included. Set a maximum charge per run in the run options if you want a hard spending cap.

### Tips

- **More jobs for one role:** split by location (`"locations": ["Austin, TX", "Dallas, TX"]`) or run
  several phrasings (`"frontend developer"`, `"react developer"`) - each is a separate search.
- **Fresh postings only:** use `datePosted: "today"` on a daily schedule and feed the dataset into a
  spreadsheet, Slack or your ATS with Apify integrations.
- **Other countries and languages:** set `country` (`gb`, `de`, `in`...) and `language` to search that
  market's Google Jobs.
- Salary is only present when Google displays it (roughly 20-40% of listings depending on the role).
- `postedAt` is derived from Google's relative time ("3 days ago"), so treat it as approximate.

### Scheduling and integrations

Run it on a schedule, then use Apify integrations (Google Sheets, Slack, Make, Zapier, webhooks) or the
API to pull the dataset as JSON, CSV or Excel.

### Fair use

This scraper reads publicly visible job listings in the same way a visitor would, does not log in and
does not bypass any access controls. Use the data in line with applicable laws and the terms of the
sites the listings come from.

# Actor input Schema

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

What to search for, one search per line, e.g. `software engineer`, `registered nurse in Austin, TX`, `marketing manager remote`. Anything you would type into Google Jobs works.

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

Optional city, state or country added to every query, e.g. `Chicago, IL` or `United Kingdom`. Leave empty if your queries already include a place. To search several places at once, use Locations below.

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

Optional list of places to search, e.g. `Chicago, IL`, `Austin, TX`, `Remote`. Every query runs once per location (combined with Location above if set), and Maximum jobs per query applies to each query-location pair. Each job records the place it was found for in `searchLocation`.

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

Only return jobs posted within this period.

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

Restrict results to remote / work-from-home jobs.

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

Only return jobs Google labels with this employment type. Other jobs are skipped and not charged; jobs with no type shown on Google are skipped too.

## `salaryOnly` (type: `boolean`):

Skip jobs where Google shows no pay information. Skipped jobs are not charged.

## `excludeCompanies` (type: `array`):

Skip jobs from these employers or staffing agencies, one per line, e.g. `Amazon`, `Robert Half`. Matches whole words in the company name, ignoring case (`Amazon` also skips `Amazon Web Services`). Skipped jobs are not charged.

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

Stop after this many jobs for each query. Google serves jobs in batches of about 10.

## `resolveApplyLinks` (type: `boolean`):

Replace Google's redirect links with the direct URL on LinkedIn, Indeed, the employer's site, etc. Adds one quick request per link (the job board itself is never visited).

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

Two-letter interface language for Google, e.g. `en`, `de`, `es`.

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

Two-letter Google country code that decides which jobs market is searched, e.g. `us`, `gb`, `de`.

## `maxConcurrency` (type: `integer`):

How many queries run in parallel.

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

Google Jobs requires Apify's Google SERP proxy group. Keep the default unless you know what you are doing.

## Actor input object example

```json
{
  "queries": [
    "software engineer in Austin, TX"
  ],
  "datePosted": "any",
  "remoteOnly": false,
  "employmentType": "any",
  "salaryOnly": false,
  "maxResultsPerQuery": 20,
  "resolveApplyLinks": true,
  "language": "en",
  "country": "us",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

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

One row per job with title, company, location, salary, posting date, employment type and the best apply link.

## `jobsFull` (type: `string`):

Every field, including highlights, the full description and every job board's apply link.

# 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 in Austin, TX"
    ],
    "maxResultsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("boosted90210/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 in Austin, TX"],
    "maxResultsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("boosted90210/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 in Austin, TX"
  ],
  "maxResultsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call boosted90210/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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