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

Scrape Google Jobs listings: title, company, location, salary, description, qualifications, benefits and every apply link. Filter by date, job type and remote.

- **URL**: https://apify.com/uber_byte/google-jobs-scraper.md
- **Developed by:** [Marlon Lee](https://apify.com/uber_byte) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 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.

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

## Google Jobs Scraper

Export Google Jobs search results with job title, company, location, source job board, salary, posting date, schedule type, remote flag, full description, highlights and every "Apply on" link. Job boards, recruiters and labor-market analysts use it to collect listings from LinkedIn, Indeed, company career sites and the other sources Google indexes, in one place. You need no API key or Google account.

### What you get

Each job is one row with:

- Search query, Google job ID, title, company, location and the job board it came from ("via")
- Salary when Google shows it, as the original text plus parsed minimum, maximum, currency and period
- Posting date (worked out from Google's "3 days ago" text) and the original text
- Schedule type (full-time, part-time, contractor, internship) and remote flag
- Full description and highlights such as qualifications, responsibilities and benefits
- Every apply option with the provider name and link (LinkedIn, Indeed, the company careers site and others)
- A share link back to the listing on Google and the search URL used

### Use cases

- **Job boards and aggregators:** fill your board with fresh listings from the sources Google indexes.
- **Recruiting and sales intelligence:** see which companies are hiring for which roles, and where.
- **Salary research:** compare advertised pay ranges by role and city.
- **Labor-market analytics:** track hiring volume and remote share over time on a schedule.
- **Job alerts:** send postings from the past 24 hours to Slack, email or your app.

### How to use the Google Jobs scraper

1. Open the Actor in Apify Console.
2. Enter one or more job searches, for example `software engineer` or `registered nurse`.
3. Add a location, and set Google's country (`gl`) and language (`hl`) if you're not searching the US in English.
4. Add filters if you want them: date posted, employment type and remote only. Set **Max jobs per query**.
5. Click **Start**, then download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

### Input example

```json
{
  "queries": ["software engineer", "data analyst"],
  "location": "Austin, TX",
  "gl": "us",
  "hl": "en",
  "datePosted": "week",
  "employmentTypes": ["FULLTIME"],
  "remoteOnly": false,
  "maxItems": 100,
  "includeDetails": true
}
```

Turn off `includeDetails` for a faster, card-only run without descriptions, highlights and apply links.

### Output example

A real card from a test run on 2026-09-29, shortened:

```json
{
  "query": "software engineer",
  "jobId": "eDKibdiJuVkhv61uAAAAAA==",
  "title": "Firmware Software Engineer",
  "company": "Bright Vision Technologies",
  "location": "Anywhere",
  "via": "LinkedIn",
  "description": "…full job description…",
  "highlights": [
    { "title": "Qualifications", "items": ["…"] },
    { "title": "Benefits", "items": ["…"] }
  ],
  "salary": { "text": "Salary Range: $125,000–$145,000 Annually", "min": 125000, "max": 145000, "currency": "$", "period": "year" },
  "postedAt": "2026-09-28",
  "postedAtText": "1 day ago",
  "scheduleType": "Full-time",
  "isRemote": true,
  "extensions": ["1 day ago", "Work from home", "Full-time", "Salary Range: $125,000–$145,000 Annually"],
  "applyOptions": [
    { "title": "Apply on LinkedIn", "provider": "LinkedIn", "link": "https://www.linkedin.com/jobs/view/…" }
  ],
  "shareLink": "https://www.google.com/search?ibp=htl;jobs&q=software+engineer+jobs+in+Austin,+TX&htidocid=eDKibdiJuVkhv61uAAAAAA%3D%3D…",
  "searchUrl": "https://www.google.com/search?q=software+engineer+jobs+in+Austin%2C+TX&udm=8&hl=en&gl=us"
}
```

`postedAt` comes from Google's relative text ("1 day ago"), so treat it as approximate.

### Pricing

You pay per job saved, with no monthly rental. Failed searches and searches with no results cost nothing in result charges. Set a maximum spend per run and the Actor stops once it reaches that limit.

### FAQ

**Is it legal to scrape Google Jobs?**
The Actor collects publicly listed job ads that Google shows to anyone without logging in. Google's terms govern automated access, and job boards own their listings, so review those terms and ask a lawyer about your use, especially if you republish ads. You're responsible for how you use the data.

**How does it work?**
It opens Google's jobs search (`google.com/search?udm=8`) in a real browser, scrolls through the results, and opens each job's detail panel to read the description and apply links.

**Will Google block it? Which proxy should I use?**
The default is Apify's Google SERP proxy. In our tests Google showed its "unusual traffic" page to every residential IP we tried (13 of 13), while the SERP proxy returned results on the first try. You can switch to another proxy group. When Google blocks a request, the Actor retries on a fresh session. It never tries to solve the CAPTCHA.

**How many jobs can I get per query?**
As many as Google loads for that search as you scroll, up to **Max jobs per query** (default 50). To get more, split a broad search into narrower queries or locations.

**Are the filters exact?**
The Actor adds the filters to the Google search ("in the last week", "full time", "remote"), then checks each job against what its card says. Jobs that don't show a date or schedule type are kept, because the Actor can't check them.

**Which languages work?**
Any `gl` and `hl` works for searching. Apply-button and chip detection is tuned for English (`hl=en`), so other interface languages may return fewer parsed fields.

**What are the limits?**

- Google changes this page's markup often. If a description comes back empty, the run saves a `DEBUG-DETAIL` page snapshot in the key-value store so the parser can be fixed.
- Salary appears only when the employer or job board publishes it.
- Google Jobs isn't available in every country. Where it isn't, searches return no cards and the run log says so.
- The Actor runs a browser, so it's slower per job than API-based scrapers.

# Actor input Schema

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

Job searches as you would type them into Google, e.g. "software engineer", "registered nurse", "barista".

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

City, region or country, e.g. "Austin, TX" or "London". Added to every query as "in <location>". Recommended: without a location Google often shows no Jobs results.

## `gl` (type: `string`):

Two-letter Google country code, e.g. us, gb, de, in.

## `hl` (type: `string`):

Google interface language. Parsing of apply buttons and chips works best with en.

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

Date posted.

## `employmentTypes` (type: `array`):

Only jobs of these types. Leave empty for all.

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

Only jobs Google marks as work from home / remote.

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

Maximum number of results to return. See the README for whether this applies per search or to the whole run.

## `includeDetails` (type: `boolean`):

Opens each job's detail panel. Turn off for a faster, card-only scrape.

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

Apify's Google SERP proxy is the default and recommended: Google shows its "unusual traffic" page to most datacenter and residential IPs.

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "location": "Austin, TX",
  "gl": "us",
  "hl": "en",
  "datePosted": "any",
  "remoteOnly": false,
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

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

No description

# 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": "Austin, TX",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("uber_byte/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": "Austin, TX",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("uber_byte/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": "Austin, TX",
  "maxItems": 10
}' |
apify call uber_byte/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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