Pricing

from $3.99 / 1,000 results

Go to Apify Store

🚀 Google Jobs Scraper

Try for free

Pricing

from $3.99 / 1,000 results

Rating

0.0

(0)

Developer

ScraperX

Actor stats

Bookmarked

Total users

Monthly active users

13 hours ago

Last modified

🚀 Google Jobs Scraper — Extract Job Listings, Salaries & Apply Links from Google Jobs

Scrape Google Jobs results across 86 countries. Search by keywords and location, or paste ready-made Google Jobs URLs, and get every listing with its title, company, location, description, job highlights, posting date, schedule type, salary and every apply link — including the original job board behind each one.

Google Jobs aggregates from LinkedIn, Indeed, Glassdoor, company career pages and dozens of regional boards. This Actor gives you all of them in one dataset.

What you get

💼 Job	🏢 Company & source	📋 Detail
Job title	Company name	Full description
Location	Company logo	Job highlights (qualifications, responsibilities, benefits)
Posted date	`via` — the board it came from	Schedule type (full-time, contract…)
Salary, where published		Extras / badges
Job ID		All apply links, with their source

Key features

Two ways to search. Provide keywords plus a location, or paste Google Jobs URLs directly. Mix several URLs in one run to cover multiple queries, locations or keyword variations at once.
86 countries. The country field sets Google's geo parameter, which genuinely changes which regional results come back — from the US and UK through India, UAE, Brazil, Nigeria, Japan, Kazakhstan and more.
Multiple apply links per job. Google Jobs often lists the same role on several boards. The applyLink array preserves them all with their sources, so you can pick the original posting rather than an aggregator copy.
Real filters. Employment type (full-time, part-time, contractor, intern), date posted (today, 3 days, week, month) and a company-name filter applied case-insensitively.
Structured job highlights. Qualifications, responsibilities and benefits come through as grouped items rather than a wall of text.
Clean output by default. Jobs missing a title or company are dropped unless you explicitly ask for them with includeUnfilteredResults.
Honest pagination controls. pagesToFetch and maxItems are both available, with the interaction between them documented rather than implicit.
Diagnostic row instead of silence. If Google returns nothing usable, the Actor writes a single labelled diagnostic record explaining what happened, including the query it ran.
Residential-backed reliability. Custom proxies are tried first if you supply them, with Apify Residential as the automatic fallback (up to 3 retries).

Use cases

Job boards and aggregators — feed a niche board with listings from every source Google indexes.
Recruitment market research — measure hiring volume by role, city and country.
Salary benchmarking — collect published salary ranges across a role and location.
Competitor hiring intelligence — filter by company name to watch exactly what a competitor is building.
Lead generation for staffing and HR tech — companies posting many roles have budget and urgency.
Job-alert automation — schedule a daily run with datePosted: "today" and push new matches to Slack or e-mail.
Labour-market analysis — compare demand for a skill across countries in one run.
Application automation — apply links with their sources feed straight into an application workflow.

How it works

You provide Google Jobs URLs, or keywords plus a location and country.
A Google Jobs query is built (or your URLs are used as-is) with your filters encoded.
Result pages are walked, roughly 10 jobs per page, up to your page or item limit.
Each listing is parsed into a flat record with company, location, description, highlights, metadata and every apply link.
Client-side filters are applied — keywords, company name, and the incomplete-row rule.
Rows stream into the dataset; if nothing usable comes back, a diagnostic record explains why.

Quick start

Open the Actor and enter Include keywords — e.g. software engineer, python.
Enter a Location (e.g. New York, NY) and pick a Country.
Set Maximum results (start with 20).
Click Start, then export the Output tab as JSON (recommended) or CSV.

Minimal input

{
  "includeKeyword": "software engineer",
  "locationName": "New York, NY",
  "countryName": "United States",
  "maxItems": 20
}

Input configuration

Source & query

Field	Type	Default	Description
`startUrls`	array	—	Google Jobs search URLs. Mix several to cover multiple queries or locations in one run. Leave empty to build the query from the fields below.
`includeKeyword`	string	—	Comma-separated keywords (`software engineer, python`). Used to build the query and to filter results client-side. Ignored when `startUrls` is provided.
`locationName`	string	—	City, region or country to focus on (`New York, NY`, `London`, `India`).
`countryName`	string	`United States`	Sets Google's geo parameter. 86 countries supported across the Americas, Europe, Africa, the Middle East and Asia-Pacific.

Filters

Field	Type	Default	Description
`companyName`	string	—	Keep only jobs whose company name contains this string (case-insensitive).
`jobType`	string	—	`FULLTIME`, `PARTTIME`, `CONTRACTOR` or `INTERN`.
`datePosted`	string	`all`	`today`, `3days`, `week`, `month` or `all`.

Pagination & output

Field	Type	Default	Description
`pagesToFetch`	integer	—	Pages to walk per URL/query (~10 jobs each). Leave empty to derive it from `maxItems` as `ceil(maxItems / 10)`. When both are set, this value wins.
`maxItems`	integer	`10`	Hard cap on total job rows across all URLs/queries.
`includeUnfilteredResults`	boolean	`false`	Also push jobs missing a title or company. Off by default for cleaner output.

Network

Field	Type	Default	Description
`proxyConfiguration`	object	Apify Residential	Custom proxy URLs are tried first (up to 3 retries), then Apify Residential as the automatic fallback.

Important scale note: Google caps a single query at roughly 100 results, and many queries exhaust earlier. To reach larger totals, supply multiple URLs or queries — different locations, or keyword variations — rather than raising maxItems on one query.

Output data

One row per job.

Field	Type	Description
`title`	string	Job title.
`companyName`	string	Hiring company.
`location`	string	Job location.
`via`	string	Which board the listing came from (LinkedIn, Indeed, a company site…).
`description`	string	Full job description.
`jobHighlights`	array	Grouped highlights — qualifications, responsibilities, benefits.
`metadata`	object	`{ postedAt, scheduleType, salary }`.
`extras`	array	Additional badges and labels Google attaches.
`applyLink`	array	Every apply link with its source.
`logo`	string	Company logo URL.
`_id`	string	Google's job identifier.

If Google returns nothing usable, a single record with _diagnostic: true is written, containing a note, a diagnosis, the query that was run and the countryCode used.

Example output (trimmed)

{
  "title": "Senior Python Engineer",
  "companyName": "Example Systems",
  "location": "New York, NY",
  "via": "LinkedIn",
  "description": "We are looking for a Senior Python Engineer to join our platform team…",
  "jobHighlights": [
    { "title": "Qualifications", "items": ["5+ years Python", "AWS experience", "CI/CD"] },
    { "title": "Benefits", "items": ["Health insurance", "401(k) match", "Hybrid working"] }
  ],
  "metadata": {
    "postedAt": "3 days ago",
    "scheduleType": "Full-time",
    "salary": "$140,000 - $175,000 a year"
  },
  "extras": ["Health insurance", "Dental insurance"],
  "applyLink": [
    { "title": "Apply on LinkedIn", "link": "https://www.linkedin.com/jobs/view/…" },
    { "title": "Apply on Example Systems", "link": "https://careers.example.com/jobs/1234" }
  ],
  "logo": "https://encrypted-tbn0.gstatic.com/images?q=…",
  "_id": "eyJqb2JfdGl0bGUiOi…"
}

Illustrative values — a live run returns current Google Jobs data.

Usage examples

Fresh jobs from the last 24 hours

{
  "includeKeyword": "data analyst",
  "locationName": "London",
  "countryName": "United Kingdom",
  "datePosted": "today",
  "maxItems": 100
}

Save as a Task with a daily Schedule for an automatic job alert.

Multi-city sweep for one role

{
  "startUrls": [
    "https://www.google.com/search?q=Product+Manager+jobs+Berlin&ibp=htl;jobs",
    "https://www.google.com/search?q=Product+Manager+jobs+Munich&ibp=htl;jobs",
    "https://www.google.com/search?q=Product+Manager+jobs+Hamburg&ibp=htl;jobs"
  ],
  "maxItems": 300
}

This is the correct way to exceed Google's ~100-results-per-query ceiling.

Watch a specific company

{
  "includeKeyword": "engineer",
  "locationName": "United States",
  "companyName": "Example Systems",
  "datePosted": "week",
  "maxItems": 100
}

Contract roles only

{
  "includeKeyword": "devops",
  "locationName": "Remote",
  "jobType": "CONTRACTOR",
  "maxItems": 50
}

Salary benchmarking

Run a broad query, export to CSV, and analyse metadata.salary — not every listing publishes one, but enough do to build a picture.

Run it from your own code

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("scraperx/google-jobs-scraper").call(run_input={
    "includeKeyword": "software engineer",
    "locationName": "New York, NY",
    "countryName": "United States",
    "datePosted": "week",
    "maxItems": 100,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    if job.get("_diagnostic"):
        print("DIAGNOSTIC:", job.get("diagnosis"))
        continue
    print(job["title"], "|", job["companyName"], "|", job["metadata"].get("salary"))

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const run = await client.actor('scraperx/google-jobs-scraper').call({
    includeKeyword: 'software engineer',
    locationName: 'New York, NY',
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

cURL

curl -X POST "https://api.apify.com/v2/acts/scraperx~google-jobs-scraper/runs?token=<YOUR_APIFY_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"includeKeyword":"software engineer","locationName":"New York, NY","maxItems":100}'

Integrations

Push jobs into Google Sheets, Airtable, Slack, Make, Zapier, Google Drive or your ATS via webhooks, and use Schedules with datePosted: "today" for a daily pipeline.

Pricing

Pay-per-event: a small Actor-start charge plus a charge per job row delivered to your dataset. You pay for listings, not run time. The diagnostic record written when Google returns nothing usable is a single row, not a full run's worth of charges.

Current rates are on the Pricing tab of this Actor's page, and Apify shows an estimate before and during every run. Residential proxy traffic is billed separately by the platform according to your plan.

Limits & good to know

Google caps one query at ~100 results. Many queries exhaust earlier. Use several URLs, locations or keyword variations to go beyond that — raising maxItems on a single query will not.
pagesToFetch overrides the value derived from maxItems when both are set.
includeKeyword is ignored when startUrls is provided — the URLs define the query.
Not every listing publishes a salary. metadata.salary is empty when Google has none.
via matters. The same role often appears through several boards; use applyLink to reach the original posting.
Incomplete rows are dropped by default. Turn on includeUnfilteredResults only if you want jobs missing a title or company.
Country selection changes results meaningfully — set it to match the market you care about.
Default run options are 4 GB memory and a 1-hour timeout — raise the timeout for many queries.

FAQ

Do I need a Google account or API key? No. The Actor reads publicly available Google Jobs results.

Which job boards does it cover? Whatever Google Jobs aggregates — LinkedIn, Indeed, Glassdoor, ZipRecruiter, company career pages and many regional boards. The via field tells you the source for each listing.

How do I get more than 100 results? Supply multiple URLs or queries — different cities or keyword variations. That is Google's limit, not the Actor's.

Can I get the direct application link? Yes — applyLink lists every option with its source, so you can choose the original posting over an aggregator copy.

How do I build a daily job alert? Set datePosted: "today", save it as a Task, and attach a daily Schedule with a Slack or e-mail integration.

Can I track one company's hiring? Yes — set companyName and the Actor keeps only matching listings.

What is the diagnostic record? A single labelled row written when Google returns nothing usable, including the query that ran and a diagnosis — so you can tell "no results" from "something broke".

Which export format should I use? JSON — jobHighlights, metadata and applyLink are nested. CSV works for title, company, location and salary.

Legal & responsible use

This Actor collects publicly available job listings — content employers publish specifically to be found. It does not log in, submit applications, or access private candidate data. Job descriptions remain the property of their authors. Use the data in line with Google's terms and applicable law, and treat any personal data (recruiter names, contact details) under GDPR and comparable regulations.