Google Jobs Scraper with Direct Apply Links avatar

Google Jobs Scraper with Direct Apply Links

Pricing

from $3.00 / 1,000 jobs

Go to Apify Store
Google Jobs Scraper with Direct Apply Links

Google Jobs Scraper with Direct Apply Links

Scrape Google Jobs by role and city, including Brazil. Get direct apply links, salary ranges, and job descriptions. A São Paulo test returned 30 unique listings in 4.4 seconds. Filter by company, date, and job type. Track new or updated jobs and export CSV, JSON, or Excel.

Pricing

from $3.00 / 1,000 jobs

Rating

0.0

(0)

Developer

roomy_tweet

roomy_tweet

Maintained by Community

Actor stats

0

Bookmarked

1

Total users

1

Monthly active users

6 days ago

Last modified

Features

Limited permissions

Share

Scrape Google Jobs (Google for Jobs, the jobs panel of Google Search) and get structured job postings for any search in 30 countries: title, company, location, posting date, job type, the full job description, the direct apply links (LinkedIn, Indeed, Glassdoor, the company's own careers page) and the salary as numbers. It works like a Google Jobs API: no login and no proxies to set up, results in JSON, CSV or Excel.

Google Jobs collects listings from thousands of job boards and career sites, so one search here covers what would otherwise take a dozen scrapers.

Why this Google Jobs scraper

  • Up to ~90 jobs per search, not just the first 10. A real browser scrolls Google's list the way a person does, until it has what you asked for or Google stops adding jobs.
  • Salary on more jobs. When Google shows no salary, the pay stated in the posting is read from its text. On US test searches that raised salary coverage from 40% to 63% of jobs.
  • Direct apply links to every site Google lists for the job, with Google's tracking removed. No Google redirects.
  • Full description and highlights: qualifications, benefits and responsibilities as lists.
  • Google's own filters (date posted, job type, remote) plus filters Google doesn't have: only or exclude companies, and only or exclude source sites. Jobs your filters remove are not charged.
  • New or updated job feeds for schedules: skip previously delivered IDs, or detect observed salary, description and application-link changes.
  • Many locations at once, Google Jobs URLs pasted from your browser, 30 countries, and labels read in English, Portuguese and Spanish.
  • Run report and daily quality check, so a change on Google's side shows up as a warning, not as silently empty results.

What you can use it for

  • Recruiting and sourcing: follow new openings for a role, a city or your competitors' companies.
  • Job boards and aggregators: fill a niche board with fresh postings and their original apply links.
  • Salary benchmarking: compare pay ranges by role, city and job type with numeric salaryMin / salaryMax.
  • Labor-market research: demand for skills, remote share, which companies are hiring where.
  • Lead generation: companies that are hiring are companies that are growing; filter by company or job type.
  • Job alerts: a scheduled run with Only new jobs sends you just what appeared since last time.
  • AI agents and RAG: the compact output keeps rows small enough for an LLM.

Quick start

  1. Type your searches in Search queries, one per line, the way you would type them into Google: registered nurse, python developer, warehouse associate.
  2. Optionally add Locations (every query runs in every location) and pick the Country.
  3. Set Maximum jobs per query: 10 is fastest; more is loaded by scrolling, up to ~90.
  4. Run it, then export the dataset as JSON, CSV or Excel, or read it through the API.
{
"queries": ["registered nurse", "software engineer"],
"locations": ["Chicago, IL", "Houston, TX"],
"country": "us",
"maxJobsPerQuery": 50
}

What you get

FieldExample
title, companyName, locationRegistered Nurse – ICU · Northwestern Medicine · Chicago, IL
viaWhere Google found it: LinkedIn, Indeed, the employer's careers page…
postedText, postedDaysAgo, postedAtApprox"2 days ago", 2, 2026-10-21
salaryText, salaryMin, salaryMax, salaryCurrency, salaryPeriod"$38.20–$57.30 an hour", 38.2, 57.3, USD, HOUR
salarySourcegoogle (Google's salary label) or description (read from the posting text)
employmentType, employmentTypes"Full-time and Part-time", [FULL_TIME, PART_TIME]
workFromHome, tagstrue · Health insurance, Dental insurance, No degree mentioned
qualifications, benefits, responsibilities, highlightsBullet lists as Google shows them
descriptionThe whole posting, line breaks kept
applyLinks[{ "title": "Apply on LinkedIn", "url": "https://www.linkedin.com/jobs/view/…", "domain": "linkedin.com" }, …]
companyLogoUrl, googleJobsUrl, jobIdGoogle's posting ID, used to skip duplicates
query, searchLocation, country, position, source, scrapedAtSearch context and rank in Google's list
searchTextUsedExact Google query for jobs found by HTTP recovery. Their position refers to that query's list.

Measured on test runs (October 2026, Google US, UK and Brazil): title, company, location, source, full description and apply links on 100% of jobs, and every apply link with its direct URL (2,313 of 2,313). Employment type on about 95% and posting date on 59–74%. Highlights on 94% of US jobs; Google did not show them for the UK and Brazilian searches tested. Salary: see Salary.

Pricing

$3.00 per 1,000 jobs ($0.003 per job saved to the dataset), plus $0.00005 per GB of memory when a run starts ($0.0002 at the default 4 GB). Proxies and compute are included: you pay nothing else.

You getYou pay
100 jobs$0.30
1,000 jobs$3.00
200 new jobs every day for a month (Only new jobs)about $18

You are not charged for:

  • a job that two of your queries both find (it is saved once);
  • jobs your filters remove (company, source, job type, date, remote);
  • with Only new jobs, jobs that earlier runs already delivered.

Apify's free plan includes $5 of monthly credit, enough for about 1,600 jobs. Set a maximum cost per run and the run stops by itself when it gets there.

Search options and filters

{
"queries": ["registered nurse", "warehouse"],
"locations": ["Houston"],
"datePosted": "week",
"employmentType": "PART_TIME",
"excludeCompanies": ["Example Staffing"],
"sources": ["LinkedIn", "Indeed"],
"maxJobsPerQuery": 30
}
  • Locations: every query is searched in every location (2 queries × 3 cities = 6 searches). A job found in two of them is saved once; searchLocation says where it was found.
  • Google Jobs URLs: paste searches straight from your browser (google.com/search?q=…&udm=8, or a shared job link). Each keeps its own search text, Google domain and language, including filters you picked on Google. They can be mixed with queries; locations are not added to them.
  • Country picks the Google domain (google.com, google.co.uk, google.com.br, google.de…), so jobs are local to that country. Interface language only changes Google's labels ("2 days ago" / "há 2 dias"); job texts stay as the employer wrote them.
  • Date posted, job type and remote are Google's own filters. Google applies them by adding words to the search (… part time in the last week), in the right language for the country, and the run report shows the exact text used. Google's filters are loose (its "contract" filter also returned full-time jobs in our tests), so jobs whose labels contradict your filter are dropped. Jobs without a label are kept.
  • Only these companies / Exclude companies match the company name as whole words, ignoring case and accents. "Amazon" matches "Amazon.com Services LLC" but not "Amazonia Foods". With an include list the whole Google list is read, since matches can be anywhere in it.
  • Only these sources keeps jobs Google shows via that site or with an apply link to it. Exclude sources drops jobs Google shows via that site, e.g. aggregators you don't want.
  • Output: compact leaves out the bullet lists and cuts the description to 500 characters (descriptionTruncated: true). Rows got about 77% smaller in tests (9.7 KB to 2.2 KB), handy for spreadsheets and AI agents. Salary is still read from the full text first.
  • Maximum jobs in total caps the whole run.

What the filters returned in test runs:

  • Part-time jobs from the last week (Houston): 33 jobs, all part-time and 7 days old or less. 9 jobs labelled full-time only were dropped and not charged.
  • Full-time jobs from the last week (Mexico City, Spanish filters): 25 of 25 matched.
  • Remote jobs from the last 3 days: 60 of 60 matched.
  • Three Chicago hospitals as "Only these companies": the whole list of 81 nursing jobs was read and the 6 from those employers were saved.

Only new jobs, for daily schedules

Turn on Only new jobs and schedule the Actor. Each run remembers the jobs it saved and later runs skip them.

{
"queries": ["registered nurse"],
"locations": ["Dallas"],
"datePosted": "3days",
"maxJobsPerQuery": 150,
"onlyNewJobs": true
}
  • The memory is a key-value store in your own Apify account (google-jobs-history-…), one per set of queries and filters. Give several schedules the same History name to share one memory. Jobs are remembered for a year; Forget saved jobs starts over.
  • The browser keeps scrolling past jobs you already have, until it finds maxJobsPerQuery new ones or Google's list ends. A recent Date posted filter keeps that list short.
  • Don't run two schedules with the same memory at the same time: the one that finishes last would overwrite what the other remembered.

In a test, two runs of the search above half an hour apart saved 89 jobs, then skipped the 71 already delivered and saved 15. Google's list is not identical from one search to the next, so "new" means new to you: some of those 15 had been posted 3 days earlier and simply weren't in the first run's list.

Google shows Jobs results 10 at a time and loads more as you scroll; there are no numbered pages.

With scrolling enabled and captchaProxy: standard, Portuguese keyword searches in Brazil first try a direct mobile Chrome session for up to 18 seconds when no date, employment type, or remote filter is set. If that session meets the job target, the Actor finishes the search. If more jobs are needed, it uses the Google SERP proxy and existing browser routes. REPORT.searches[].browser.attempts records the mobile attempt.

  1. The first 10 jobs of each query come from a single request through Apify's Google SERP proxy.
  2. More jobs can be collected by scrolling the Jobs tab in Chrome, with up to three routes. For keyword searches in Brazil, a short first page or a browser CAPTCHA can trigger recovery through the remaining Google SERP attempts. After a successful recovery request, up to two of those requests can run in parallel when more than ten jobs are still needed. After a browser CAPTCHA, the Actor can resume the remaining browser routes if recovery saves zero jobs. If recovery saves some jobs and still falls short, the Actor can try the direct connection once if it has not already used it. Recovery keeps the location and requested filters, deduplicates by job ID, and can return a different order from the scrolled list. REPORT.searches[].serpRecovery shows which queries were tried and how many jobs they added.

captchaProxy defaults to standard. With scrolling enabled, selecting one of these options permits extra Apify proxy charges:

  • residential gives the first search that needs more jobs one country-matched browser session. It opens the Jobs tab directly, limits the session to 35 seconds, and allows up to 40 intercepted Google requests. Residential proxy charges depend on transferred data. The attempt appears in REPORT.searches[].browser.attempts. Residential proxy
  • unblocker makes up to one HTTPS request per run after a browser CAPTCHA, without following redirects. TLS certificate verification is disabled in this dedicated public-search client because the proxy can present its own certificate. It can add jobs from one result page. The attempt appears in REPORT.searches[].unblocker. Unblocker

Set jobsProvider to searchapi to use the provider's Google Jobs pagination. Set SEARCHAPI_API_KEY as an environment secret. The provider receives the search text and country and returns up to ten jobs per request. The Actor requests another page only when it still needs jobs. searchApiMaxRequests defaults to four calls across the whole run. scrollWithBrowser: false limits each search to one page. REPORT.provider tracks total requests. This mode works locally and uses the SearchApi account's quota. Google Jobs API

Local recovery update (7 November): a browser page with no jobs no longer cancels the remaining recovery attempts when the first page already returned jobs. The Jobs URL is rebuilt from the successful query, country and language; a contradicted empty page can be retried once with local job wording such as “vagas”. Results from partial attempts are combined without repeating IDs. Existing time and attempt limits still apply.

The browser now waits for actual page/card changes instead of fixed sleeps, fills the search in one operation, and transfers complete job cards instead of the whole Google page. It preserves cards removed by scrolling and jobs collected before a later browser error.

Measured in test runs (October 2026):

SearchAsked forGotNote
registered nurse + software engineer, Chicago50 each10057 s for both
desenvolvedor + analista de dados, São Paulo40 each8084 s for both
nurse, London15091Google's list ended at 91
data analyst, London15094Google's list ended at 94

A volume test of 40 US searches (10 occupations × 4 cities, 20 jobs each) took 15 minutes. The first 10 jobs came back for all 40 on the first try (median 23 s, slowest 64 s). Scrolling got everything asked for, or everything Google listed, for 36 of the 39 searches that needed it; the other 3 kept their first 10. Since then a second retry from another IP was added, and the 5 searches tested afterwards all completed.

Expect about 90–100 jobs at most per search, because that is where Google stops adding to the list, and 20 seconds to 2 minutes of scrolling per query.

Salary, also when Google doesn't show one

Google labels a salary on only part of the postings, while many others state the pay in their text ("Pay Range $110,000.00 - $135,000.00", "Salary: £30.80 - £35.20 per hour"). When Google shows no salary, the Actor reads it from the posting and marks it salarySource: "description". It only takes an amount with a currency and a pay word or period next to it. It skips money that is something else (company revenue, bonuses, allowances, budgets, tips), and checks that the size fits the period.

Measured on 1,385 jobs from the test runs:

GoogleSalary from Google aloneWith salaries read from the text
US40%63%
UK55%68%
Brazil, Mexico13%, 36%unchanged: those postings rarely state an amount

As an accuracy check, the same reader ran on jobs that do have a Google salary. Where it found an amount (310 jobs), 284 (92%) matched Google's: same period, overlapping range. Most of the others are Google converting an hourly rate to a yearly one, or showing a different band than the text. Filter on salarySource if you only want Google's.

Track changes to known postings

Use trackChanges: true to compare each delivered posting with its last remembered content. Rows carry changeType (NEW, UPDATED or UNCHANGED), changedFields, firstSeenAt, previousSeenAt and lastSeenAt. The comparison includes salary, description, application URLs, title, employer, location and employment details. Ranking, scrape timestamps, whitespace and common URL tracking parameters do not create changes.

For a feed of new and updated jobs:

{
"queries": ["software engineer"],
"locations": ["Chicago, IL"],
"country": "us",
"onlyChanges": true,
"historyName": "engineering-watch",
"maxJobsPerQuery": 100
}

onlyChanges enables comparison and omits unchanged postings without a job charge. It also revisits known jobs so salary or description edits can be found. onlyNewJobs continues to skip previously delivered IDs; choose one of these two delivery modes. A posting disappearing from search results is not marked closed. Missing descriptions or fields can reflect Google serving different detail, so changes describe the content observed by this Actor rather than a verified employer edit.

Old ID-only histories migrate automatically. In changes-only mode, their first content observation establishes a baseline for free; subsequent observations can identify updates. Histories are scoped by country and job ID, capped at 150,000 postings and retain recent observations for up to a year. Avoid overlapping runs using the same history name: storage updates across separate runs are not transactional.

Salary evidence and focused feeds

salaryPeriodSource distinguishes a period stated in the source (explicit) from a period inferred from the amount/currency (inferred). salaryEvidence identifies the label or nearby wording used. Nominal salaryAnnualMin / salaryAnnualMax are supplied only for explicit periods, in the original currency, with salaryAnnualizationFactor: HOUR 2,080; DAY 260; WEEK 52; MONTH 12; YEAR 1. These are transparent comparison assumptions, not exchange-rate conversions or a prediction of actual earnings. Upper-only and lower-only ranges remain open.

Additional filters:

  • strictFilters: true: with a date or job-type filter selected, drop postings whose corresponding label is missing.
  • requireSalary: true: require a positive numeric salary and identified currency.
  • minAnnualSalary with required salaryCurrency: keep only postings with a known lower salary bound meeting that nominal annual floor. Inferred periods and upper-only ranges do not qualify.
  • titleKeywords / excludeTitleKeywords: include any matching title word/phrase or exclude a match. Case and accents are ignored; C++, C# and .NET stay distinct.
{
"queries": ["software engineer"],
"locations": ["Austin, TX"],
"country": "us",
"requireSalary": true,
"minAnnualSalary": 100000,
"salaryCurrency": "USD",
"titleKeywords": ["engineer", "developer"],
"excludeTitleKeywords": ["intern"],
"datePosted": "week",
"strictFilters": true
}

The existing job event also covers updated jobs delivered in changes-only mode. No new paid event is introduced by these options. Collection and browser work still consume infrastructure even when filters or unchanged content leave no job rows to bill.

Output example

Values below are illustrative, not a real posting.

{
"jobId": "AbCdEfGhIjKlMnOpAAAAAA==",
"title": "Registered Nurse - Medical/Surgical",
"companyName": "Example Health",
"location": "Chicago, IL",
"via": "LinkedIn",
"postedText": "3 days ago",
"postedDaysAgo": 3,
"postedAtApprox": "2026-10-20",
"salaryText": "$38.20–$57.30 an hour",
"salaryMin": 38.2,
"salaryMax": 57.3,
"salaryCurrency": "USD",
"salaryPeriod": "HOUR",
"salarySource": "google",
"employmentType": "Full-time",
"employmentTypes": ["FULL_TIME"],
"workFromHome": false,
"tags": ["Health insurance", "Dental insurance", "Paid time off"],
"qualifications": ["Current RN license in Illinois", "BLS certification"],
"benefits": ["Tuition reimbursement", "403(b) with match"],
"responsibilities": ["Assess and monitor patients", "Administer medications"],
"highlights": [{ "title": "Qualifications", "items": ["Current RN license in Illinois", "BLS certification"] }],
"description": "Example Health is hiring a Registered Nurse for our Medical/Surgical unit…\n\nWhat you will do\n• Assess and monitor patients…",
"applyLinks": [
{ "title": "Apply on LinkedIn", "url": "https://www.linkedin.com/jobs/view/example-4400000000", "domain": "linkedin.com" },
{ "title": "Apply on Example Health Careers", "url": "https://careers.example-health.org/jobs/12345", "domain": "careers.example-health.org" }
],
"companyLogoUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:…",
"googleJobsUrl": "https://www.google.com/search?ibp=htl;jobs&q=registered%20nurse&htidocid=AbCdEfGhIjKlMnOpAAAAAA%3D%3D",
"query": "registered nurse",
"searchLocation": "Chicago, IL",
"country": "us",
"language": "en",
"position": 4,
"source": "browser",
"scrapedAt": "2026-10-23T12:00:00.000Z"
}

The dataset's Overview view shows the main columns side by side.

Use it from the API, schedules and AI agents

Call the Actor from your code with Apify's client libraries. In Python:

from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("roomy_tweet/google-jobs-scraper").call(run_input={
"queries": ["data analyst"],
"locations": ["Austin, TX"],
"datePosted": "week",
"maxJobsPerQuery": 30,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
print(job["title"], job["companyName"], job["salaryMin"], job["applyLinks"][0]["url"])

In JavaScript:

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('roomy_tweet/google-jobs-scraper').call({ queries: ['data analyst'], locations: ['Austin, TX'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
  • Schedules: run it daily or hourly from Apify Console with Only new jobs on.
  • Integrations: send results to Google Sheets, Slack, Zapier, Make or your own webhook when a run finishes.
  • AI agents: available through Apify's MCP server like any Apify Actor; use the compact output to keep responses small.

Run report and quality check

Each run saves a REPORT record in its key-value store with one line per query: jobs wanted and saved, how the first page and the scrolling went, the exact search text used, and a status:

StatusMeaning
OKGot the number of jobs you asked for
ALL_AVAILABLEGoogle listed fewer jobs than you asked for, and you got all of them
PARTIALScrolling was blocked or ran out of time; you got what was loaded (at least the first 10 when the first request worked)
NO_CHANGESWith Only new or updated jobs: no observed content changes among the postings read
NO_NEW_JOBSWith Only new jobs: every job Google listed was already delivered by an earlier run
NO_MATCHESGoogle listed jobs, but none passed your filters; nothing is charged
NO_RESULTSGoogle has no jobs for this query
FAILEDNothing could be loaded
SKIPPEDA run limit (total jobs, duration or your spending limit) was reached first

Every run also checks its own quality (REPORT.health, REPORT.qualityProblems, and a warning in the status line). It flags job listings Google showed but that could not be read, the usual sign of a Google layout change. A page like that is never reported as "no results". It also flags more than 20% of saved jobs missing a core field, every search failing, and scrolling stuck at 10 jobs everywhere. Turn on Fail the run if quality drops for scheduled runs, so Apify's failed-run notification tells you. The Actor is checked this way every day by its author.

Good to know

  • Maximum per search is about 90–100 jobs, Google's own limit. For more, split a broad search into narrower ones (by city, seniority or specialty); duplicates between them are removed and not charged.
  • Salary fields: salaryMin and salaryMax are equal for a single amount. "Up to £48,000" leaves salaryMin empty, and "from $20/hour" leaves salaryMax empty.
  • postedAtApprox is the scrape date minus Google's "N days ago"; Google gives no exact timestamp.
  • Bare queries: Google answers some queries without the word "jobs" (just "pharmacist") with no job results. The Actor then searches again with "jobs" ("vagas", "empleo") added, and the report shows the text it used.
  • Countries: full runs tested on Google US, UK, Brazil and Mexico; Spain's result page was checked too. The other countries use the same page format but have not been checked one by one.
  • No login, no cookies. Only public Google pages are read.

FAQ

How much does it cost? $3.00 per 1,000 jobs, proxies included. Repeats, filtered-out jobs and (with Only new jobs) jobs already delivered are free. See Pricing.

How fast is it? The first 10 jobs of a query take 1 to 65 seconds, typically about 20. Scrolling for more takes 20 seconds to 2 minutes per query, and two queries scroll at the same time with the default 4 GB of memory. 40 queries of 20 jobs took 15 minutes.

Do I need proxies or a Google account? No. Proxies are included and no login is used.

Which countries and languages? 30 countries, including the US, UK, Canada, Australia, India, Germany, France, Brazil, Mexico and Spain. Google's labels are read in English, Portuguese and Spanish; other countries are searched locally with the English interface.

Why do some jobs have no salary? Neither Google nor the posting text states one. See Salary for how often each does.

Does it return recruiter e-mails or phone numbers? No. It returns what Google Jobs shows: the posting, the company and the apply links.

Why did a query return exactly 10 jobs? Check the requested limit and the search status in REPORT. A PARTIAL search stopped before reaching the requested count. Its browser and recovery attempts show whether Google blocked further collection.

Can I monitor new postings every day? Yes: turn on Only new jobs and schedule the Actor. Jobs already delivered are skipped and not charged.

Is it legal to scrape Google Jobs? The Actor reads publicly available job postings only. Postings can still contain personal data, such as a recruiter's name, so check that your use complies with the laws that apply to you, such as the GDPR, and consult a lawyer if in doubt.