# Google Jobs Scraper (`cirkit/google-jobs-scraper`) Actor

Scrape Google Jobs listings by keyword and location. Get job title, company, salary range, job type, posted date, remote flag, full description, qualifications, benefits and direct apply links from LinkedIn, Indeed and employer sites.

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

## Pricing

$2.50 / 1,000 job postings

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

### What is Google Jobs Scraper?

**Google Jobs Scraper** extracts job postings from [Google Jobs](https://www.google.com/search?q=jobs\&udm=8), the job search built into Google that aggregates listings from LinkedIn, Indeed, Glassdoor, ZipRecruiter, company career sites and thousands of other job boards. Give it a job title and a location, and it returns every posting as a clean, structured record: title, company, location, salary range, job type, posted date, full description, qualifications, benefits and the **direct apply links**.

Because Google Jobs already merges postings from every major board, one run replaces scraping LinkedIn, Indeed and Glassdoor separately.

- 🔎 **Search any job title in any city or country**, with Google's own filters for date posted, employment type and remote work
- 💰 **Salary ranges parsed into numbers** (min, max, period and currency), ready for compensation benchmarking
- 🔗 **Real apply URLs**, not Google redirect links: the employer's careers page, LinkedIn, Indeed and every other place the job is listed
- 📝 **Full job descriptions** plus Google's extracted qualifications, responsibilities and benefits
- ♻️ **Deduped across searches**, so a posting that matches two of your searches is returned, and billed, once
- ⚡ **No browser, no login, no cookies.** Fast HTTP requests through Apify's Google SERP proxy

### What data does Google Jobs Scraper extract?

| Field | Example |
|---|---|
| `title` | Registered Nurse, Evening Shift |
| `companyName` | Alden Lincoln Park Rehabilitation |
| `location` | Chicago, IL |
| `via` | Indeed |
| `postedAt` / `postedAtDate` | 5 days ago / 2026-09-25T13:46:36Z |
| `salary` | 38–42 an hour |
| `salaryMin` / `salaryMax` / `salaryPeriod` / `salaryCurrency` | 38 / 42 / HOUR / USD |
| `scheduleType` / `employmentTypes` | Full-time / \["Full-time"] |
| `isRemote` | false |
| `degreeRequirement` | No Degree Mentioned |
| `benefits` | \["Paid time off", "Dental insurance", "Health insurance"] |
| `qualifications` / `responsibilities` / `benefitsHighlights` | Bullet lists extracted by Google |
| `description` | Full posting text |
| `applyUrl` | https://www.indeed.com/viewjob?jk=28b60064e33cfc26 |
| `applyOptions` | Every apply link with publisher name and a direct-employer flag |
| `companyLogoUrl` | Company logo image |
| `jobId` / `googleJobsUrl` | Google's posting id and a shareable Google Jobs link |
| `searchQuery` / `searchArea` / `matchedQuery` / `position` | Which search found it, where Google searched, and its rank |

### How to scrape Google Jobs

1. Click **Try for free** and open the Input tab.
2. Add one or more **job searches**, for example `data analyst` or `registered nurse`.
3. Set a **location** such as `Austin, Texas`, `London` or `Germany`. Google otherwise picks the area from the proxy location, which is random.
4. Optionally filter by **date posted**, **employment type** or **remote only**.
5. Click **Start** and download the results as JSON, CSV, Excel or HTML, or pull them through the Apify API.

### Input example

```json
{
    "queries": ["software engineer", "data analyst"],
    "location": "New York, NY",
    "maxResultsPerQuery": 50,
    "datePosted": "week",
    "employmentType": "FULLTIME",
    "remoteOnly": false
}
```

### Output example

```json
{
    "searchQuery": "nurse",
    "searchArea": "Chicago, IL",
    "position": 4,
    "jobId": "h2vSPj9rlGO0oXHdAAAAAA==",
    "title": "Registered Nurse- (RN)- Evening Shift (3pm-11pm)",
    "companyName": "Alden Lincoln Park Rehabilitation and Health Care Center",
    "location": "Chicago, IL",
    "via": "Indeed",
    "postedAt": "5 days ago",
    "salary": "38–42 an hour",
    "salaryMin": 38,
    "salaryMax": 42,
    "salaryPeriod": "HOUR",
    "salaryCurrency": "USD",
    "scheduleType": "Full-time",
    "isRemote": false,
    "benefits": ["Paid time off", "Dental insurance", "Health insurance"],
    "applyUrl": "https://www.indeed.com/viewjob?jk=28b60064e33cfc26",
    "applyOptions": [
        { "publisher": "Indeed", "isDirect": true, "url": "https://www.indeed.com/viewjob?jk=28b60064e33cfc26" },
        { "publisher": "ZipRecruiter", "isDirect": true, "url": "https://www.ziprecruiter.com/..." }
    ],
    "description": "JOB SUMMARY. Responsible to provide direct nursing care..."
}
```

### How many results can I get?

Google Jobs shows ten postings per page. To go deeper, the scraper walks Google's own filter chips (full time, part time, contract, internship, posted today, this week, this month, remote, no degree) and dedupes what they return. That typically yields **50 to 100 unique postings per search**. For larger datasets, run more job titles or more locations in one run: `nurse` across 20 cities returns well over a thousand postings.

### How much does it cost to scrape Google Jobs?

Google Jobs Scraper uses pay per result pricing: **$2.50 per 1,000 job postings**, with no monthly rental. You only pay for postings written to your dataset, and duplicates are never billed.

| Postings | Price |
|---|---|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |

Every Apify account includes free monthly usage credit, so you can try the scraper at no cost. Set **Max postings in total** to cap what a run can spend.

### Use cases

- **Job boards and aggregators**: feed fresh listings from every source Google indexes into your own site.
- **Recruiting and sales intelligence**: find companies hiring for a role in a territory, then reach out while the requisition is open.
- **Salary benchmarking**: collect published pay ranges by title, city and seniority.
- **Labor market research**: track demand for skills, remote share and posting velocity over time.
- **Job alerts**: schedule the actor daily with `datePosted: today` and push new postings to Slack, email or a spreadsheet.

### Integrations

Connect Google Jobs Scraper to Make, Zapier, n8n, Google Sheets, Slack, Airbyte or your own backend with Apify integrations and webhooks, or call it from Python and JavaScript with the Apify API client.

### FAQ

#### Is it legal to scrape Google Jobs?

Google Jobs Scraper collects publicly visible job postings that employers publish to be found. It does not log in or access anything behind an account. Postings can include recruiter names or contact details, so check your use against applicable data protection law, such as GDPR, and consult a lawyer if you are unsure.

#### How much does it cost?

$2.50 per 1,000 postings, billed per result. A search that finds nothing writes one notice row explaining why, billed as a single result ($0.0025).

#### Why do I get fewer results than I asked for?

Google caps each view at ten postings, and narrow searches in small towns simply have fewer jobs. Broaden the title, choose a larger city, remove filters, or add more searches.

#### Do I need a Google account, cookies or an API key?

No. The scraper needs nothing from you except a search. It runs on Apify's Google SERP proxy, which is included with your Apify account.

#### Can I scrape jobs outside the United States?

Yes. Set **Location** to any city, region or country and **Google country** to the matching code, for example `gb` for the United Kingdom or `de` for Germany. Keep the language as `en` for fully parsed salary and job type fields; other languages still return titles, companies, descriptions and apply links.

#### Why is a posting's salary empty?

Salary appears only when the employer publishes it. Roughly a third of US postings include a range.

#### Can I get the full job description?

Yes, every row includes the complete posting text in `description`, with no extra charge.

# Actor input Schema

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

What to search for on Google Jobs, one search per line, for example "software engineer" or "registered nurse". Each search is run separately and postings are deduped across all of them.

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

City, region or country to search in, for example "New York, NY", "Austin, Texas", "London" or "Germany". Leave empty to let Google choose from the proxy location, which is random, so setting this is strongly recommended.

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

Upper limit of unique postings for each search. Google shows ten postings per page, so the actor walks Google's own filter chips (full time, part time, contract, posted this week, and so on) to go deeper. Expect roughly 50 to 100 unique postings per search at most; add more searches or locations for more volume.

## `maxItems` (type: `integer`):

Hard cap on rows across every search, and therefore on what the run can cost. Leave empty for no cap.

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

Only postings published within this window.

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

Only postings of this schedule type.

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

Only postings Google classifies as remote or work from home.

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

Two-letter Google country code (gl), for example us, gb, ca, de or in. Sets the Google market and the salary currency. Use Location to target a city.

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

Google interface language code (hl), for example en, de, fr or es.

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

Turn Google's redirect links into the employer's or job board's real URL (one extra lightweight request per apply option). Turn off to keep Google's links and run slightly faster.

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

This actor requires the Apify GOOGLE\_SERP proxy group, the supported route to Google search pages. The default is correct for almost every run. Datacenter and residential groups return a JavaScript shell with no postings in it.

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "location": "New York, NY",
  "maxResultsPerQuery": 20,
  "datePosted": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "country": "us",
  "language": "en",
  "resolveApplyLinks": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

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

Every Google Jobs posting matched by the searches, one row per posting, with description, salary and apply links.

## `resultsCsv` (type: `string`):

The same postings as a downloadable CSV file.

## `salaries` (type: `string`):

Postings with parsed salary ranges, pay period and currency.

# 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"
    ],
    "location": "New York, NY",
    "maxResultsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

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

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

```

## MCP server setup

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