# Google Jobs Scraper (Job Listings, Companies, Sources) (`webdatatools/google-jobs-scraper`) Actor

Google Jobs Scraper returns Google Jobs listings for a search: title, company, location, posting date, description and source links. Uses the Apify GOOGLE_SERP proxy, no browser.

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

## Pricing

from $3.20 / 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

### What is Google Jobs Scraper?

Google Jobs Scraper returns the job listings Google Jobs shows for a search: job title, company, location, posting age, pay (when shown), employment type and the sites that list the job. It fetches the Google Jobs results (`udm=8`) through Apify's GOOGLE_SERP proxy group, so it needs no browser. One row per job card.

### What data does Google Jobs Scraper extract?

- `position`: rank of the job card in that query's results
- `query`: the search used
- `title`: job title
- `company`: employer
- `location`: city and region as Google shows it (e.g. `New York, NY`)
- `postedAt`: posting age as Google shows it (e.g. `2 days ago`)
- `salary`: pay as Google shows it (e.g. `174K–252K a year`), when present
- `employmentType`: e.g. `Full-time`, `Contractor`, when present
- `sourceLinks`: names of the sites that list the job (e.g. `LinkedIn`, `Indeed`). These are site names, not job URLs (see FAQ)
- `searchUrl`: the Google search URL used
- `fetchError`: filled only when the proxy was unavailable

### How to use Google Jobs Scraper

1. Enter a job search with a location in **Search queries**, e.g. `data analyst in New York`.
2. Set **Max jobs per query** (up to 100).
3. Run it and download the dataset as JSON, CSV or Excel.

Queries without a location return no job cards from Google through this proxy (checked 23 Oct 2026: `data analyst` returned no jobs, `software engineer jobs in New York` returned 10).

### Example input

```json
{
    "queries": ["data analyst in New York", "software engineer in Austin"],
    "maxResultsPerQuery": 20,
    "countryCode": "us",
    "languageCode": "en"
}
```

### Example output

Real output from a cloud run on 23 Oct 2026 (2 queries, 20 rows in total):

```json
{
  "position": 1,
  "query": "data analyst in New York",
  "title": "Senior Analyst - Data Analytics",
  "company": "American Express",
  "location": "New York, NY",
  "postedAt": "1 day ago",
  "salary": "89,250–150,250 a year",
  "employmentType": "Full-time",
  "sourceLinks": ["LinkedIn"],
  "searchUrl": "http://www.google.com/search?q=data+analyst+in+New+York&udm=8&hl=en&gl=us",
  "fetchError": null
}
```

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array of strings | `["data analyst in New York"]` | Job searches. Include a location. |
| `maxResultsPerQuery` | integer 1-100 | 20 | Rows per query. |
| `countryCode` | string | `us` | Google country (`gl`). |
| `languageCode` | string | `en` | Google interface language (`hl`). |

### Pricing

Pay per job row (pay-per-event, default dataset item): $0.004 per job on the FREE plan, volume tiers down to $0.0028 (PLATINUM, DIAMOND), plus a small start event. Measured on one 23 Oct 2026 cloud run of 20 rows: $0.0168 total (about 2 GOOGLE_SERP requests at $0.0025 each plus compute). That is about $0.84 per 1,000 jobs at the measured run; more runs are needed to firm up the estimate.

### FAQ

**Why are no jobs returned for my query?** Google shows job cards only when the query names a place. Use `job title in City`.

**Why are `sourceLinks` site names, not URLs?** The job apply links are not present in the HTML the proxy returns; Google loads them with JavaScript. The site names are the only source data in that response.

**Does it return all pages of jobs?** Google loads more jobs by scrolling. This Actor reads the first page of job cards (about 10 per query) and does not scroll.

**Does it need a login or a browser?** No. It uses the Apify GOOGLE_SERP proxy group only.

### Support and feedback

Open an issue on the Actor's Console page, or contact the author through Apify.

# Actor input Schema

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

Job searches, one per line (e.g. "data analyst in Istanbul").

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

Rows per query.

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

Two-letter country code.

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

Two-letter language code.

## Actor input object example

```json
{
  "queries": [
    "data analyst in New York"
  ],
  "maxResultsPerQuery": 20,
  "countryCode": "us",
  "languageCode": "en"
}
```

# Actor output Schema

## `results` (type: `string`):

All jobs from this run.

# 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": [
        "data analyst in New York"
    ]
};

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

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

```

## MCP server setup

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