Google Jobs Scraper - Pay-Per-Result

The most efficient, reliable, and developer-friendly Google Jobs scraper for Apify platform

Getting Started

1. Enter a job search keyword in the query field (required).
2. Optionally add location, country, and language to target results.
3. Set num_results to control how many listings to retrieve (10–1000).
4. Run the Actor; results appear in the Dataset tab, one row per job.
5. Export as JSON, CSV, or Excel from the dataset export menu.

---

This Actor uses price per results billing model. We also have a price per event billing model that operates the same way. If you prefer price-per-event billing, please see our Google Jobs Scraper - Price Per Event actor here.

Python Quick Start Example

A complete Python example using the Apify client is available on GitHub:

github.com/johnisanerd/Apify-Google-Jobs-Pay-Per-Result

Clone the repo, run uv sync, add your API key, and you are scraping Google Jobs in minutes.

---

🌟 Why Choose This Scraper?

The Google Jobs data scraper delivers enterprise-grade performance with these advanced capabilities:

Performance & Reliability: Built with modern Python async/await patterns and optimized for high-throughput scraping with intelligent rate limiting.

Cost-Effective: Provides for consistent, reliable results without the overhead of browser automation, cookies, or other rental costs.

Lightning-Fast Search & Retrieval: Search any keyword or job title across Google Jobs with blazing-fast performance. Retrieve comprehensive results in seconds, not minutes, with intelligent caching and optimization.

Precision Targeting & Advanced Filtering: Pinpoint exact locations with radius-based searches, filter by country and language, and apply sophisticated targeting parameters. Get precisely the job data you need, when you need it.

Rich, Structured Data Extraction: Extract complete job information, including application links, and comprehensive job descriptions. Our advanced parsing ensures you get clean, structured data ready for immediate use.

Enterprise-Grade Configuration & Flexibility: Built for developers and businesses who demand reliability. Highly configurable with intuitive controls, comprehensive error handling, and robust logging. Focus on your business logic while we handle the complexity of job scraping.

No Hidden Costs or Rental Fees: We do not charge monthly rentals, our scraper operates on a pay-per-result model. Scale up or down based on your actual needs without being locked into expensive subscriptions.

Pricing

This Google Jobs scraper uses a pay-per-result model: you pay only for the job listings returned to the dataset, with no monthly rental and no start fee. A run of 1,000 listings costs about $15, and you can cap spend per run with ACTOR_MAX_PAID_DATASET_ITEMS. Runs that return no data are not charged for results. The Billing Model section below covers cost control in detail.

💰 Billing Model

This Actor uses a Pay-Per-Result (PPR) billing model. You are charged based on the number of job results produced and stored in the dataset.

Controlling Costs

To limit the maximum number of results and control costs, you can set the ACTOR_MAX_PAID_DATASET_ITEMS environment variable. For example:

• Setting ACTOR_MAX_PAID_DATASET_ITEMS=1000 will cap results at 1,000, resulting in a maximum charge of $15.00
• Setting ACTOR_MAX_PAID_DATASET_ITEMS=500 will cap results at 500, resulting in a maximum charge of $7.50

The Actor will automatically check your available funds before starting and will stop gracefully if insufficient funds are available.

What Counts as a Result?

Each job listing that is successfully pushed to the dataset counts as one result. This includes:

• Individual job postings with complete metadata
• Each job record with search parameters, timestamps, and job details

🚀 Features

Core Capabilities

• Advanced Search: Support for complex queries with location, country, and language filtering
• Intelligent Pagination: Automatic handling of Google Jobs pagination with configurable limits
• Location Targeting: Precise location-based searches with radius support
• Multi-Language: Support for international job markets

Data Quality

• Clean Output: Automatic structured data metadata for clean, production-ready data
• Structured Results: Consistent JSON structure across all job listings
• Comprehensive Fields: Job title, company, location, description, job highlights, related links, and posting metadata
• Metadata Tracking: Page-level analytics and search performance metrics

📖 Usage Examples

Basic Job Search Example

Search for a programmer job in San Francisco, CA.

{
  "query": "Software Engineer",
  "location": "San Francisco, CA"
}

Advanced Job Search Example

Search for a job in San Francisco, CA, with a radius of 25 miles, and return 1,000 results. Limit to 10 pages.

{
  "query": "Software Engineer",
  "location": "San Francisco, CA",
  "country": "us",
  "language": "en",
  "google_domain": "google.com",
  "num_results": 1000,
  "max_pagination": 10,
  "include_lrad": false,
  "lrad_value": "25"
}

Company Filter Example

Filter out jobs from specific companies using case-sensitive matching. This example searches for "Barista" jobs and filters out all results from Starbucks.

Using text input (single or comma-separated):

{
  "company_filter": "Starbucks",
  "query": "Barista"
}

Using array input (recommended for multiple companies):

{
  "company_filter_list": ["Starbucks", "Target", "Walmart"],
  "query": "Barista"
}

Note: The company filter uses case-sensitive matching, so "Starbucks" will match exactly. You can use either:

• company_filter: Single company name or comma-separated list (e.g., "Starbucks, Dunkin', Peet's Coffee")
• company_filter_list: Array of company names (takes precedence if both are provided)

Job Source Filter Example

Filter out jobs from specific job sources/platforms. This example filters out jobs from Indeed and ZipRecruiter.

Using text input:

{
  "via_filter": "Indeed, ZipRecruiter",
  "query": "Software Engineer"
}

Using array input (recommended):

{
  "via_filter_list": ["Indeed", "ZipRecruiter", "JobTarget"],
  "query": "Software Engineer"
}

Note: Common job sources include "Indeed", "ZipRecruiter", "JobTarget", "Snagajob", "LinkedIn", etc. The via_filter_list array takes precedence over via_filter text input if both are provided.

🔍 Input References

Input Parameters

Parameter	Type	Required	Default	Description
query	str	✅	-	Job search query
location	Optional[str]	❌	None	Job location (city, state, country)
country	str	❌	"us"	Country code for search
language	str	❌	"en"	Language code
google_domain	str	❌	"google.com"	Google domain to use
num_results	int	❌	100	Maximum results to return
max_pagination	Optional[int]	❌	None	Maximum pages to fetch
include_lrad	bool	❌	False	Include location radius
lrad_value	Optional[str]	❌	None	Location radius value
company_filter	Optional[str]	❌	None	Filter out jobs from specific companies (single name or comma-separated list, case-sensitive). Alternative to company_filter_list.
company_filter_list	Optional[List[str]]	❌	None	Array of company names to filter out. Takes precedence over company_filter if both are provided. Case-sensitive matching.
via_filter	Optional[str]	❌	None	Filter out jobs from specific job sources/platforms (single source or comma-separated list, case-sensitive). Examples: "Indeed", "ZipRecruiter", "JobTarget", "Snagajob". Alternative to via_filter_list.
via_filter_list	Optional[List[str]]	❌	None	Array of job source names to filter out. Takes precedence over via_filter if both are provided. Case-sensitive matching.
max_delay	int	❌	1	Delay in seconds between API requests (0–10). Increase if you hit rate limits.
output_file	Optional[str]	❌	None	Custom filename for saving results locally. Leave empty for auto-generated filename.
company_filter_regex	bool	❌	False	Enable regex pattern matching for company filters. When enabled, filter values are treated as regular expressions.

What You Get

Each run returns one clean, structured JSON row per job listing, ready for a database, a spreadsheet, or an AI agent. Every record can include:

• Core fields: title, company_name, location, and the source board in via (for example via LinkedIn, via Indeed).
• Full descriptions: the complete description text plus job_highlights (qualifications, responsibilities, and benefits grouped by section).
• Apply and reference links: related_links with direct apply URLs and the pages Google surfaced for the role.
• Posting metadata: detected_extensions with posted_at, schedule_type, and experience_level when Google surfaces them, plus a stable job_id.
• Search context: total_jobs_found, pages_processed, and search_metadata echoing your query, location, country, and language.

Export any run as JSON, CSV, or Excel from the dataset tab, or pull it straight from the API.

📊 Output Format

Job Listing Structure

Each row in the dataset represents one job listing. The envelope fields (total_jobs_found, pages_processed, search_metadata, pagination_info) are also stored per row for reference.

{
  "title": "Senior Software Engineer",
  "company_name": "Tech Corp",
  "location": "San Francisco, CA",
  "via": "via LinkedIn",
  "description": "We are looking for a senior engineer to join our platform team...",
  "job_highlights": [
    {
      "title": "Qualifications",
      "items": ["5+ years Python experience", "Experience with cloud platforms"]
    },
    {
      "title": "Benefits",
      "items": ["Health insurance", "Remote work options"]
    }
  ],
  "related_links": [
    {"link": "https://company.com/careers/123", "text": "Apply on company site"},
    {"link": "https://linkedin.com/jobs/view/123", "text": "View on LinkedIn"}
  ],
  "thumbnail": "https://encrypted-tbn0.gstatic.com/images?q=...",
  "job_id": "eyJqb2JfdGl0bGUiOiJTZW5pb3IgU29mdHdhcmUgRW5naW5lZXIi...",
  "detected_extensions": {
    "posted_at": "2 days ago",
    "schedule_type": "Full-time",
    "experience_level": "Mid-senior level"
  },
  "extensions": ["2 days ago", "Full-time", "Mid-senior level", "Health insurance"],
  "total_jobs_found": 150,
  "pages_processed": 15,
  "search_metadata": {
    "query": "Software Engineer",
    "location": "San Francisco, CA",
    "country": "us",
    "language": "en"
  }
}

Note: Fields like salary, experience_level, and schedule_type are only present when Google surfaces that data for a listing. detected_extensions may be partial or empty for some jobs.

MCP Integration

This Actor is compatible with the Model Context Protocol (MCP). AI assistants and agents can call it directly as a tool without manual setup.

Use the Apify MCP server and pass query plus optional parameters as tool arguments. The Actor returns structured job listings the agent can process immediately.

Example agent prompt

"Search Google Jobs for 'Data Engineer' roles in Austin, TX, and return 50 results."

The agent calls this Actor automatically and receives structured JSON job listings in response.

🎯 Google Jobs Scraper Use Cases

The Google Jobs scraper powers a range of recruiting, market-research, and product workflows:

• Job board backfill: keep a niche or regional job board full by pulling fresh Google Jobs listings on a schedule, then de-duplicating on job_id.
• Recruitment and sourcing: track open roles for target titles and locations, and route new postings to your ATS or a Slack channel.
• Labor-market research: measure hiring demand by role, company, and city over time, and chart which via sources dominate a market.
• Lead generation: find companies that are actively hiring, then enrich them with firmographics and contact data for sales outreach.
• Salary and skills analysis: aggregate job_highlights and posting metadata to benchmark requirements and compensation signals across a role.

🔌 Integrations: Automate Google Jobs Data Collection

A single run answers one question ("what Data Engineer roles are open in Austin today?"). The real value comes from running this Google Jobs scraper repeatedly, so new postings land in your stack the moment they appear. See the full list of Apify platform integrations.

Tasks and Schedules (the core recipe). Save one task per thing you monitor (a role plus a city, or a company watchlist), then attach a schedule from the Actor's Actions, then Schedule menu. Useful cron strings: 0 7 * * * (daily at 7 AM), 0 */6 * * * (every six hours), 0 9 * * 1 (Mondays). One schedule can trigger many tasks at once, so a single morning run can refresh every role you track. The job board backfill task is a ready-made example of this pattern.

n8n. Use the Apify n8n integration to build a four-step monitor: a Schedule Trigger, then the Apify Run Actor node pointing at this Actor, then a Filter (for example drop postings already in your database), then a Slack or email node.

Dedicated n8n node. Looking for a purpose-built n8n node for Google Jobs data? The companion Google Jobs Scraper returns the same listings and ships a dedicated n8n community node, n8n-nodes-google-jobs-api.

Make and Zapier. The same pattern works no-code with Make and Zapier: trigger on a schedule, run the Actor, and route the new listings wherever you need them.

Store the history (Supabase). Send each run's rows into a table so a hiring history accumulates. No-code: the n8n Apify node, then a Supabase node. Or in Python, using the real Actor ID and the flat output fields:

from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_TOKEN")
supabase = create_client("YOUR_SUPABASE_URL", "YOUR_SUPABASE_KEY")

run = apify.actor("johnvc/google-jobs-scraper---pay-per-result").call(run_input={
    "query": "Data Engineer",
    "location": "Austin, TX",
    "num_results": 100,
})
rows = list(apify.dataset(run["defaultDatasetId"]).iterate_items())
supabase.table("google_jobs").upsert(rows).execute()

MCP and AI agents. Add this Google Jobs scraper as a tool in Claude Code (free trial), Claude Cowork (free trial), or Cursor through the Apify MCP server so an agent can pull live listings (see the MCP Integration section above).

Webhooks. For anything custom, fire an Apify webhook on ACTOR.RUN.SUCCEEDED to push each run's dataset into your own service.

📰 Articles and Guides

• Job Postings API for Job Boards: Backfill Listings at $0.013 per Job: a walkthrough of using this Google Jobs scraper to backfill a job board with fresh listings at a low per-job cost, with the task setup and output structure explained.

🔗 Related Tools

Building a recruiting or lead-generation pipeline? These tools from the same catalog pair well with Google Jobs data:

• LinkedIn Jobs API: pull job listings and salary data from LinkedIn to combine with your Google Jobs coverage.
• Crunchbase Company API: enrich the companies behind each posting with funding rounds, investors, and firmographics.
• Google Maps Places API: find and enrich local employers with addresses, phone numbers, and websites for outreach.
• Google Jobs Scraper (Price Per Event): the same job data on a per-event billing model, handy for high-volume runs.

Older alternatives such as nuclear_quietude/google-jobs-scraper-api exist, but that Actor has not been updated since December 2025, carries a one-star rating, and reports a lower success rate. This API is actively maintained and returns clean, structured fields including job_highlights, related_links, and company and job-source filters.

FAQ and Limitations

Why are some jobs missing salary or experience level data?

Google does not surface this information for all listings. The detected_extensions object will be partial or empty when Google has not extracted it.

What is the maximum number of results?

num_results accepts 10–1,000. For larger datasets, run multiple searches with different queries or locations.

What does the via field mean?

It indicates the job board where Google found the listing (e.g., via LinkedIn, via Indeed, via ZipRecruiter).

Does this Actor work for all countries?

Yes. For non-US searches, set google_domain to your country's domain (e.g. google.de for Germany, google.fr for France) and use a city in location (e.g. Berlin, Munich) rather than a country name. The same search often returns nothing on google.com but full results on the local domain. Also prefer a job-title style query ("Product Manager", "Registered Nurse") over a descriptive phrase, since Google Jobs matches on job titles. If Google still returns nothing for a location filter, the actor automatically retries with the city folded into the query (for example, "Product Manager Berlin"), so location-targeted searches keep working.

Can I schedule this Google Jobs Scraper?

Yes. Any run can be automated on a schedule. Create a saved task with your query and location, then attach a schedule from the Actor's Actions, then Schedule menu. Useful cron strings are 0 7 * * * for daily at 7 AM, 0 */6 * * * for every six hours, and 0 9 * * 1 for Monday mornings, and one schedule can trigger many tasks at once. See the Integrations section above for the full monitoring recipe.

Should I use an API or a Web Scraper for Google Jobs?

Both, and this Actor is both. An official jobs API is usually rate limited, quota bound, and missing fields, while this Actor gives you the same data as a no-code web scraper or a clean API endpoint you call yourself, with no quotas. If you want the background, here is a neutral definition of web scraping. The listings themselves come from Google for Jobs.

Can I integrate this Google Jobs Scraper with other apps?

Yes. It connects to almost any cloud service through Apify integrations: Make, Zapier, Slack, the Apify n8n node, and webhooks on ACTOR.RUN.SUCCEEDED for custom actions. See the Integrations section above for full recipes.

Can I use the Google Jobs API programmatically?

Yes. The Apify API runs the Actor, schedules it, and fetches datasets, and the apify-client package exists for both Node.js and Python. See the Actor's API tab for ready-made snippets.

Can I use this Google Jobs Scraper through an MCP Server?

Yes. Add it as a tool in any MCP client (Claude, Cursor, and others) through the hosted Apify MCP server with the Actor-specific URL https://mcp.apify.com/?tools=actors,docs,johnvc/google-jobs-scraper---pay-per-result. In Claude Code (free trial) or Claude Cowork (free trial) your agent can then answer prompts like "find remote nursing jobs and save them to a sheet" with live data. See the Apify MCP docs.

How does the Google Jobs API work, and how do I get started?

Enter a job title in query, optionally set location, country, and language, then run the Actor. It searches Google Jobs, paginates through the results, and returns one structured row per listing. There is no separate Google Jobs API key to obtain: you call this Actor through the Apify API or MCP, or run it from the Store. For code, clone the example repo on GitHub.

How else can I collect job and hiring data?

Pair this Google Jobs scraper with related tools in the same catalog: the LinkedIn Jobs API for another major job source, the Crunchbase Company API to enrich the companies posting roles, and the Google Maps Places API to find and enrich local employers for outreach.

---

Made with ❤️

Transform your job search automation with the most reliable and efficient Google Jobs scraper on the market.

Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

• Backfill a job board with Google Jobs results - Backfill your job board with fresh Google Jobs listings.
• Export Google Jobs results to JSON by API - Pull structured Google Jobs results by API for any role.
• Find data scientist jobs in New York from Google Jobs - Find data scientist jobs in New York aggregated from Google Jobs.
• Find remote nursing jobs from Google Jobs by API - Find remote registered nurse jobs aggregated across job boards via Google Jobs.
• Find software engineer jobs in Austin from Google Jobs - Find software engineer jobs in Austin aggregated from Google Jobs.
• Export Google Jobs Listings to CSV

Last Updated: 2026.07.13