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

Google Jobs Scraper Extract job listings from Google Jobs with titles, companies, locations, salaries, job types, posting dates, descriptions, and apply links. Export clean data to JSON, CSV, Excel, or XML for recruitment, lead generation, market research, and job analytics.

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

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🚀 Google Jobs Scraper

Scrape Google Jobs at scale — titles, companies, locations, descriptions, salaries, schedule types, posting dates, apply links, logos, and rich highlights — with a built-in smart proxy fallback that adapts to Google's block walls so you do not have to.

***

### 🌟 Why Choose Us?

- 🛡️ **Smart 3-tier proxy fallback** — starts direct, escalates to datacenter, then residential (3 retries). One block does not kill the run.
- 🌐 **Bulk URL support** — drop in many Google Jobs search URLs in a single run.
- 🧠 **Two ways to query** — paste search URLs or just supply keywords + location.
- 📦 **Rich payload** — full descriptions, qualifications, benefits, responsibilities, salary, schedule type, posted-at, multiple apply links, logos.
- 🔴 **Live streaming** — every job is pushed to the dataset the moment it is parsed. A crash mid-run still leaves you with the rows already scraped.
- 🌍 **Multi-language friendly** — date / salary / schedule detection works across English, Spanish, Portuguese, Indonesian, Italian, French, German and more.

***

### 🔑 Key Features

| Feature | Description |
| --- | --- |
| 🌐 Bulk URLs | Paste many Google Jobs URLs at once |
| 🔍 Keyword + Location mode | Skip URLs and just give us what to search for |
| 🏢 Company filter | Keep only jobs from a target company |
| 💼 Job type filter | Full-time, Part-time, Contractor, Internship |
| 📅 Date filter | Today, 3 days, week, month, or any |
| 📄 Pagination | Walk N pages of results per query |
| 🎁 Hard cap | Limit total rows pushed to the dataset |
| 🛡️ Proxy fallback | Auto-escalates on block |
| 📊 Two dataset views | Overview + Full Details, both with emoji column labels |

***

### 📥 Input

```json
{
  "startUrls": [
    { "url": "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs" }
  ],
  "includeKeyword": "software engineer, python",
  "locationName": "New York, NY",
  "countryName": "United States",
  "companyName": "",
  "jobType": "FULLTIME",
  "datePosted": "week",
  "pagesToFetch": 5,
  "maxItems": 100,
  "includeUnfilteredResults": false,
  "requestDelay": 1.5,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

**Field reference**

- **`startUrls`** — array of Google Jobs URLs. If empty, the actor builds one from the keyword + location fields.
- **`includeKeyword`** — comma-separated keywords used both to build the query and to filter results.
- **`locationName`** — focus location (city / region / country).
- **`countryName`** — country name used to set Google's `gl` parameter.
- **`companyName`** — keep only jobs whose company contains this substring.
- **`jobType`** — empty (any), `FULLTIME`, `PARTTIME`, `CONTRACTOR`, `INTERN`.
- **`datePosted`** — `all`, `today`, `3days`, `week`, `month`.
- **`pagesToFetch`** — pages of results to walk per URL (~10 jobs / page).
- **`maxItems`** — hard cap on total rows pushed.
- **`includeUnfilteredResults`** — if `true`, keep jobs missing a title or company.
- **`requestDelay`** — polite seconds between requests; random jitter added.
- **`proxyConfiguration`** — Apify proxy editor. Defaults to **no proxy** so the actor uses its own ladder.

***

### 📤 Output

Each pushed item:

```json
{
  "title": "Senior Android Engineer",
  "companyName": "1001",
  "location": "Erbil",
  "via": "Built In",
  "description": "Job Description: 1001 is seeking …",
  "jobHighlights": [
    { "title": "Qualifications",  "items": ["6+ years Android dev", "Strong Kotlin", "TDD experience"] },
    { "title": "Benefits",        "items": [] },
    { "title": "Responsibilities","items": ["Design and build features", "Code reviews", "Mentor juniors"] }
  ],
  "metadata": {
    "postedAt": "6 days ago",
    "scheduleType": "Full-time",
    "salary": ""
  },
  "extras": ["6 days ago", "Full-time"],
  "applyLink": [
    { "title": "Apply on Built In", "link": "https://builtin.com/job/…" }
  ],
  "logo": "https://encrypted-tbn0.gstatic.com/images?q=tbn:…",
  "_id": "7rxg7R41fZScxVBtAAAAAA=="
}
```

***

### 🚀 How to Use (Apify Console)

1. Log in at <https://console.apify.com> → **Actors**.
2. Open this actor (`google-jobs-scraper`).
3. Choose **either**:
   - Paste one or more Google Jobs URLs into **Google Jobs URLs**, **OR**
   - Fill in **Include keywords** + **Location** + **Country**.
4. Tweak **Job type**, **Date posted**, **Pages to fetch**, **Maximum results** as needed.
5. (Optional) Set **Proxy configuration** — by default the actor decides on its own.
6. Click **Start**.
7. Watch the **Logs** tab — each scraped job is announced in real time.
8. Open the **Storage → Dataset** tab to inspect the **Overview** and **Full Details** views.
9. Export to JSON / CSV / XLSX.

***

### 🤖 Use via API

```bash
curl -X POST "https://api.apify.com/v2/acts/<USER>~google-jobs-scraper/runs?token=$APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "startUrls": [{ "url": "https://www.google.com/search?q=React+Developer+jobs&ibp=htl;jobs" }],
       "maxItems": 100,
       "pagesToFetch": 5,
       "datePosted": "week"
     }'
```

***

### 🛡️ Smart proxy fallback

```
DIRECT  ─►  DATACENTER  ─►  RESIDENTIAL (×3 retries)
```

- The run starts **without a proxy**.
- On a Google block (HTTP 403/429/503, captcha page, "unusual traffic"), the actor switches to **DATACENTER**.
- If that also blocks, the actor switches to **RESIDENTIAL** and will try up to **3 times** with fresh residential sessions.
- Once a tier succeeds, the actor **locks** to that tier for the rest of the run.
- Every transition is logged with a 🛑/🔒/🌐 marker for full traceability.

If you set a custom proxy in **Proxy configuration**, that takes precedence — but if it fails, the actor still drops down to the fallback ladder.

***

### ⭐ Best Use Cases

- 📈 Job-market analytics and dashboards
- 🤝 Lead generation for recruitment agencies
- 🛠️ Building niche job-board aggregators
- 🧪 Competitive-intelligence around hiring signals
- 🤖 Feeding AI workflows that need fresh hiring data

***

### 💰 Pricing

**Pay-per-Result.** The actor uses Apify's synthetic `apify-default-dataset-item` event — you are charged per job row pushed to the default dataset. No charge for failed runs, no fixed monthly fee.

The Apify Store page shows the live per-item price.

***

### ❓ Frequently Asked Questions

**Q: Do I need a proxy?**
A: No. The actor tries direct first and only spins up paid proxies if Google blocks the direct request.

**Q: What if my custom proxy fails?**
A: The actor logs the failure and drops down to its own fallback ladder so the run keeps going.

**Q: Why are some jobs missing salary / posted date?**
A: Google does not always render those chips. The actor falls back to language-aware regex over the full card text, but if Google omits the data entirely there is nothing to recover.

**Q: How fresh are the results?**
A: As fresh as Google's Jobs vertical itself — usually within hours of being posted.

**Q: Can I scrape only a specific company?**
A: Yes — fill in **Filter by company**.

***

### 📬 Support & Feedback

Found a bug or want a new feature? Open an issue on the Actor's GitHub or message us via the Apify Console.

***

### ⚖️ Cautions / Legal

- Data is collected only from **publicly available Google Jobs search results**.
- You are responsible for compliance with GDPR, CCPA, anti-spam laws, and Google's Terms of Service.
- Respect target sites' rate limits and `robots.txt`.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Google Jobs search URLs. You can mix multiple URLs to scrape several queries / locations in a single run. Leave empty if you prefer to build the query from the keyword + location fields below.

## `includeKeyword` (type: `string`):

Comma-separated keywords used to build a Google Jobs query (e.g. "software engineer, python"). Also used to filter results client-side. Ignored when 'Google Jobs URLs' is provided.

## `locationName` (type: `string`):

City, region or country name to focus the search on (e.g. "New York, NY", "London", "India").

## `countryName` (type: `string`):

Country used to set Google's geo (`gl`) parameter. Affects which regional results Google returns.

## `companyName` (type: `string`):

Optional. Only keep jobs whose company name contains this string (case-insensitive).

## `jobType` (type: `string`):

Filter results by employment type.

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

Filter results by how recently the job was posted.

## `pagesToFetch` (type: `integer`):

Optional. How many pages of results to walk per URL/query (each page returns ~10 jobs). Leave empty to auto-derive from Max results: ceil(maxItems / 10). When both are set, this value wins.

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

Hard cap on total job rows pushed to the dataset across all URLs/queries. Note: Google's `/async/callback:550` endpoint caps a single query at ~100 results (the `start>=100` ceiling), and many queries exhaust earlier. To reach larger totals, provide multiple URLs/queries (e.g. different locations or keyword variations) in the Source URLs list.

## `includeUnfilteredResults` (type: `boolean`):

If on, also push jobs missing a title or company. Off by default for cleaner output.

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

Optional custom proxy URLs. The scraper always uses Apify RESIDENTIAL as the fallback (up to 3 retries). If you provide custom proxy URLs here, those are tried first (up to 3 retries) and then it falls back to RESIDENTIAL.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"
  ],
  "includeKeyword": "software engineer, python",
  "locationName": "New York, NY",
  "countryName": "United States",
  "jobType": "",
  "datePosted": "all",
  "maxItems": 10,
  "includeUnfilteredResults": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/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 = {
    "startUrls": ["https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/google-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraper-engine/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/google-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/S2hRfP2Tb0J7BYbRp/builds/dD12ZMNQVJVq82bSQ/openapi.json