# Google Jobs Scraper — Salaries, Apply Links & Descriptions (`kaz_kakyo/google-jobs-search`) Actor

Search Google Jobs by keyword and location in any country and language. Each job comes with company, location, posted time, salary when shown, every apply link Google lists and the full description. Pay per job returned plus a small fee per results page; searches that return nothing are free.

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

## Pricing

from $1.50 / 1,000 job returneds

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 — Salaries, Apply Links & Descriptions

Search Google Jobs by job title or keyword plus a location, in any country and language. Every job comes back as one clean row with:

- **title, company, location** and the **board Google found it on** (LinkedIn, Indeed, a company career site…)
- **posted time** and **salary** exactly as Google shows them (salary is `null` when the listing shows none)
- **every apply option** Google lists, each with its **direct URL** — not just one link
- the **full job description** (email addresses and phone numbers are removed)
- employment type and benefit chips, Google's job ID and a share link

It works logged out, through Apify's Google SERP proxy. You need no Google account, API key or proxy setup of your own.

### How much does it cost?

You pay per result, and only for what is delivered:

| Event | Price | When |
|---|---|---|
| `job-result` | $0.0015 | One job row delivered to your dataset |
| `search-page` | $0.003 | One Google results page that delivered at least one new job |

A full page of 10 jobs costs **$0.018**, about **$1.80 per 1,000 jobs**. Apify also bills its fixed start event (`apify-actor-start`, $0.00005 per run).

You are **not** charged for:

- searches that return no jobs, or that Google blocks or times out
- jobs already delivered earlier in the same run (the same job often appears in several searches)
- status rows

Set **Max jobs per run** or a maximum total charge on the run to cap spending. The actor stops before it would exceed your limit.

### Input

| Field | Example | Notes |
|---|---|---|
| `queries` | `["registered nurse", "ICU nurse"]` | One search per entry, up to 25 |
| `location` | `Chicago` | Added to every search; leave empty to put locations inside the queries |
| `country` | `us` | Two-letter code Google searches from: `gb`, `de`, `fr`, `in`, … |
| `language` | `en` | `de`, `fr`, `pt-BR`, … Labels like the posted time follow this language |
| `maxJobsPerSearch` | `10` | Google shows about 10 jobs per results page |
| `maxResults` | `100` | Cap on paid rows for the whole run |
| `concurrency` | `3` | Searches run in parallel; a Google page can take a minute or more |

### Output

```json
{
  "title": "Registered Nurse (RN) - Surgical ICU",
  "company": "Advocate Health Care",
  "location": "Chicago, IL",
  "via": "LinkedIn",
  "postedText": "5 hours ago",
  "salaryText": "38.20–57.30 an hour",
  "otherChips": ["Full-time"],
  "applyOptions": [
    { "label": "Apply on LinkedIn", "url": "https://www.linkedin.com/jobs/view/…" },
    { "label": "Apply on Indeed", "url": "https://www.indeed.com/viewjob?jk=…" }
  ],
  "description": "Job highlights … full text …",
  "jobId": "cBWq3BXymbOY9-Z6AAAAAA==",
  "searchQuery": "registered nurse",
  "searchLocation": "Chicago",
  "country": "us",
  "language": "en"
}
```

Every search outcome is listed in the free **status** dataset: no jobs found, blocked, timed out, and so on. A summary with delivered and charged counts is saved as `OUTPUT` in the run's key-value store.

### Honest limits

- **About 10 jobs per search.** Google's jobs page shows roughly 10 results, and loading more is not supported yet. To get more jobs, run more specific searches, such as several titles or several nearby locations. Duplicates across searches are free.
- **Slow pages.** A Google results page can take anywhere from 20 seconds to over 3 minutes through the SERP proxy. Searches run in parallel. A page that times out or is blocked is retried once at no cost to you; if it still fails, it becomes a free status row instead of failing the run.
- **Search in the local language.** Google Jobs may show no results for an English query in a non-English market (for example "software engineer Tokyo"), while the same search in Japanese returns jobs. Empty searches are free and listed as `no_jobs_found`.
- **Text as shown.** `postedText` and `salaryText` are Google's display text in your chosen language. They are not parsed into dates or numbers.
- **No personal data.** The actor does not collect recruiter profiles. It removes email addresses and phone numbers from descriptions.

### Data source

Google Jobs results pages on google.com (the jobs vertical), fetched logged out through the Apify Google SERP proxy. The listings themselves come from the boards and career sites Google aggregates. Each apply URL points there.

# Actor input Schema

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

One search per entry, for example "registered nurse" or "data analyst python". Up to 25 per run.

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

City, region or country added to every search, for example "Chicago" or "Berlin". Leave empty to put the location inside each query yourself.

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

Two-letter country code Google searches from, for example us, gb, de, fr, in.

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

Interface language code, for example en, de, fr or pt-BR. Labels such as the posted time follow this language.

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

Stop each search after this many new jobs. Google returns about 10 jobs per results page.

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

Hard cap on paid job rows for the whole run.

## `concurrency` (type: `integer`):

How many searches run at the same time. A Google results page can take a minute or more.

## Actor input object example

```json
{
  "queries": [
    "registered nurse"
  ],
  "location": "Chicago",
  "country": "us",
  "language": "en",
  "maxJobsPerSearch": 10,
  "maxResults": 100,
  "concurrency": 3
}
```

# Actor output Schema

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

One row per job listing: title, company, location, source board, posted time, salary, apply links and full description.

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

Counts of delivered jobs, charged pages and every search outcome.

# 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": [
        "registered nurse"
    ],
    "location": "Chicago"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaz_kakyo/google-jobs-search").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": ["registered nurse"],
    "location": "Chicago",
}

# Run the Actor and wait for it to finish
run = client.actor("kaz_kakyo/google-jobs-search").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": [
    "registered nurse"
  ],
  "location": "Chicago"
}' |
apify call kaz_kakyo/google-jobs-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kaz_kakyo/google-jobs-search"
        }
    }
}
```

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/iHavJi5t7DknXIlDf/builds/8uCixBML76OddutA5/openapi.json