# Google Jobs Scaper (`toolsnmoreapi/google-jobs`) Actor

Search Google Jobs by job title, keyword, and location. This actor returns structured job listings with titles, companies, locations, salaries, descriptions, job types, apply links, and stable job IDs.

- **URL**: https://apify.com/toolsnmoreapi/google-jobs.md
- **Developed by:** [ToolsAPI](https://apify.com/toolsnmoreapi) (community)
- **Categories:** Automation, AI, Jobs
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 API & Job Scraper

Extract Google Jobs search results using a job query and location. This Apify Actor is designed as a reusable jobs-data API that returns clean, structured JSON for recruiting tools, job boards, lead generation workflows, hiring research, labor market analysis, and automation pipelines.

Google Jobs is powerful because it brings together job listings from many different job platforms, company career pages, staffing sites, and job boards into one search experience. Instead of checking each hiring platform one by one, this actor helps you collect Google Jobs results in a structured dataset that can be used in your own apps, dashboards, spreadsheets, and workflows.

This actor helps you collect job titles, company names, locations, salaries when available, posting age, job descriptions, job types, apply links, source URLs, work mode, and stable job IDs in a structured Apify dataset.

---

### 🚀 What does this actor do?

This Google Jobs scraper automates job search data collection and delivers normalized job records including:

- **Cross-Platform Job Discovery:** Google Jobs surfaces listings from many job boards, employer career pages, staffing sites, and hiring platforms in one place
- **Job Details:** Job title, company, location, and description
- **Compensation Data:** Salary or pay range when shown in Google Jobs results
- **Posting Data:** Posted date or relative posting age when available
- **Job Type:** Full-time, part-time, contract, internship, remote, hybrid, or on-site indicators when available
- **Work Mode:** Remote, hybrid, or on-site when detected
- **Apply Links:** Application URLs and source names when available
- **Stable IDs:** A generated `jobId` for deduplication and integrations
- **CSV and JSON Export:** Saves structured results to the Apify dataset and key-value store
- **API Access:** Use Apify API endpoints to call the actor from other apps
- **Debug Output:** Saves debug files when Google blocks or returns no extractable results

---

### 💡 Use Cases

- **Recruiting Research:** Find active job postings by role and location
- **Job Board Enrichment:** Pull job listings into your own platform or database
- **Lead Generation:** Discover companies hiring for specific roles
- **Market Research:** Track demand for skills, titles, and roles across regions
- **Salary Research:** Compare visible pay ranges across jobs and markets
- **Hiring Intelligence:** Monitor competitor hiring activity
- **Cross-Platform Job Search:** Use Google Jobs as a discovery layer across many job boards and employer websites
- **Automation Workflows:** Send job data to Google Sheets, Airtable, CRMs, dashboards, or internal tools
- **API Products:** Use Apify as the hosted backend for a jobs-data API

---

### 📋 Input Configuration

#### Required Fields

- **Query:** The job title, keyword, skill, or search phrase to search for, such as `software engineer`, `business analyst`, `warehouse associate`, or `sales manager`
- **Location:** The city, region, state, province, or country to search in, such as `Toronto Canada`, `Austin TX`, `London UK`, or `New York NY`

#### Optional Fields

- **Max Pages:** Maximum number of Google Jobs result pages to process
- **Language:** Google interface language, such as `en`
- **Country:** Google country code, such as `ca`, `us`, `gb`, or `au`
- **Proxy Option:** Residential proxy, auto/default Apify proxy, or no proxy
- **Retries per Page:** Number of retry attempts if Google blocks a page
- **Request Delay:** Delay between page loads to reduce blocking risk
- **Include Raw Data:** Include raw extracted data for debugging
- **Save Debug Files:** Save screenshots, HTML, and debug JSON when blocked or no results are found

---

### 📥 Example Input

```json
{
  "query": "business analyst",
  "location": "Toronto Canada",
  "maxPages": 1,
  "country": "ca",
  "language": "en",
  "proxyGroup": "residential",
  "maxRetriesPerPage": 3,
  "requestDelayMs": 12000,
  "saveDebugFiles": true
}
````

***

### 📤 Output Data

The actor returns structured records with the following fields:

| Field | Description |
|---|---|
| `title` | Job title |
| `company` | Company or employer name |
| `location` | Job location shown in the result |
| `salary` | Salary, hourly rate, or pay range when available |
| `postedAt` | Posting age, such as `3 days ago`, when available |
| `description` | Job description or visible job text |
| `jobType` | Job type or work arrangement when available |
| `workMode` | Remote, hybrid, or on-site when detected |
| `applyLinks` | List of application links with source names and URLs |
| `sourceUrl` | First visible source URL when available |
| `jobId` | Stable generated job identifier |
| `searchQuery` | Original query used for the run |
| `searchLocation` | Original location used for the run |
| `country` | Google country code used |
| `language` | Google language used |
| `scrapedAt` | Timestamp when the result was collected |

***

### 📦 Example Output

```json
{
  "title": "Business Analyst",
  "company": "Example Company",
  "location": "Toronto, ON",
  "salary": "$75K - $95K a year",
  "postedAt": "3 days ago",
  "description": "We are looking for a Business Analyst to join our team...",
  "jobType": "Full-time",
  "workMode": "Hybrid",
  "applyLinks": [
    {
      "source": "Company website",
      "url": "https://example.com/jobs/123"
    }
  ],
  "sourceUrl": "https://example.com/jobs/123",
  "jobId": "google_jobs_abc123",
  "searchQuery": "business analyst",
  "searchLocation": "Toronto Canada",
  "country": "ca",
  "language": "en",
  "scrapedAt": "2026-06-03T14:00:00.000Z"
}
```

***

### 🔌 API Usage

After deploying this Actor to Apify, other apps can call it through the Apify API.

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~google-jobs-api/run-sync-get-dataset-items?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "business analyst",
    "location": "Toronto Canada",
    "maxPages": 1,
    "country": "ca",
    "language": "en",
    "proxyGroup": "residential",
    "requestDelayMs": 12000
  }'
```

The response is a JSON array of normalized job listings.

***

### 📊 Downloading Results

Results are saved to the default Apify dataset.

From Apify Console, you can export the dataset as:

- JSON
- CSV
- Excel
- XML
- HTML
- RSS

When results are found, the actor also saves these files to the key-value store:

```text
jobs.csv
jobs.json
OUTPUT
```

If Google blocks the run or no jobs are extracted, debug files may be saved:

```text
debug-*.html
debug-*.png
debug-*.json
```

***

### ⚠️ Proxy and Blocking Notice

Google may block automated traffic, especially from datacenter, free, shared, or heavily used proxy IPs. If Google returns a reCAPTCHA or unusual traffic page, the actor will return a clear `blocked` status and save debug files instead of returning incorrect data.

For best results, use:

- Low `maxPages`, starting with `1`
- Slow request delays, such as `12000` milliseconds or higher
- `maxConcurrency` set to `1`
- Residential proxies if available on your Apify plan
- Fewer repeated searches in a short period of time

Free/default proxy access may not be enough for Google Jobs. Residential proxies may improve reliability, but they do not guarantee success. Google controls access to its pages and may still block automated requests.

***

### 🧪 Run Statuses

The actor saves a run summary to the key-value store as `OUTPUT`.

Possible statuses:

| Status | Meaning |
|---|---|
| `succeeded` | Jobs were found and saved |
| `blocked` | Google returned a reCAPTCHA or unusual traffic page |
| `no_results` | The page loaded, but no jobs were extracted |

Example blocked output:

```json
{
  "query": "business analyst",
  "location": "Toronto Canada",
  "maxPages": 1,
  "country": "ca",
  "language": "en",
  "proxyGroup": "residential",
  "totalSaved": 0,
  "status": "blocked",
  "reason": "Google returned a reCAPTCHA or unusual traffic page after retries.",
  "blockedAttempts": 4,
  "datasetItems": 0,
  "csvFile": null,
  "jsonFile": null,
  "debugFilesPattern": "debug-*.html, debug-*.png, debug-*.json"
}
```

***

### 🔍 Popular Searches

- Business analyst
- Software engineer
- Data analyst
- Product manager
- Warehouse associate
- Sales representative
- Customer service representative
- Registered nurse
- Delivery driver
- Project manager
- Marketing manager
- Accountant
- Electrician
- Plumber
- Administrative assistant
- Remote customer support

***

### ✅ Best Practices

Use specific job queries instead of overly broad searches.

Good examples:

```text
business analyst finance
software engineer react
registered nurse night shift
warehouse associate forklift
sales development representative remote
project manager construction
```

Avoid vague searches like:

```text
job
work
hiring
anything remote
best jobs
```

For better results, include the role, seniority, skill, industry, or work mode in the query and use a clear location.

***

### ⚙️ Recommended Settings

For testing, start with:

```json
{
  "query": "business analyst",
  "location": "Toronto Canada",
  "maxPages": 1,
  "country": "ca",
  "language": "en",
  "proxyGroup": "residential",
  "maxRetriesPerPage": 3,
  "requestDelayMs": 12000
}
```

For larger searches, use:

```json
{
  "query": "business analyst finance",
  "location": "Canada",
  "maxPages": 2,
  "country": "ca",
  "language": "en",
  "proxyGroup": "residential",
  "maxRetriesPerPage": 3,
  "requestDelayMs": 15000
}
```

Avoid running very broad searches with high page limits. Specific queries usually return cleaner and more useful data.

***

### ❓ FAQ

#### What can I use this actor for?

You can use it for recruiting research, job board enrichment, hiring intelligence, salary research, company lead generation, and automated jobs-data workflows.

#### Why use Google Jobs instead of scraping only one job board?

Google Jobs is useful because it can surface job listings from many different sources, including job boards, company career pages, staffing sites, and hiring platforms. This gives you a broader view of available jobs without needing to check each platform separately.

#### Does this actor work on the Apify Free plan?

The actor can run on the Apify Free plan, but Google may block free/default proxy traffic. For Google Jobs, residential proxies are recommended when available. Even with residential proxies, successful extraction is not guaranteed because Google may still return a reCAPTCHA or unusual traffic page.

#### Do paid Apify users get guaranteed results?

No. Paid users with residential proxy access are more likely to get results than free/default proxy users, but Google may still block automated requests. The actor includes session handling, retries, block detection, and debug files, but it does not guarantee Google will serve job results every time.

#### What should I do if the run is blocked?

Try:

- Lowering `maxPages` to `1`
- Increasing `requestDelayMs`
- Using residential proxies if available
- Running fewer searches back-to-back
- Trying again later
- Checking the saved debug files

#### Does it return apply links?

Yes, when apply links are visible and extractable from the loaded results. Some listings may not expose complete apply links directly.

#### Can I call it as an API?

Yes. Once deployed on Apify, you can call it through Apify API endpoints and receive JSON results from the default dataset.

#### Can I export the results?

Yes. Results are saved to the Apify dataset, which can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML from Apify. The actor also saves `jobs.csv` and `jobs.json` to the key-value store when results are found.

#### Why did I get zero results?

There are three common reasons:

1. Google returned a reCAPTCHA or unusual traffic page.
2. Google returned a page layout the actor could not extract yet.
3. There were no visible job listings for the query and location.

Check `OUTPUT` and the debug files to see what happened.

***

### 🧑‍💻 Developer Notes

This actor is designed to work as both an Apify Console tool and an API backend.

It uses:

- PlaywrightCrawler
- Apify Proxy configuration
- Crawlee SessionPool
- Cookie persistence per session
- Block detection
- Session retirement on block
- Retry handling
- Dataset output
- CSV and JSON key-value store output
- Debug HTML, screenshot, and JSON files

The default dataset is the main API output. Use Apify’s `run-sync-get-dataset-items` endpoint when you want another app to call the actor and receive job listings directly as JSON.

Common integration targets include:

- Google Sheets
- Airtable
- Zapier
- Make
- CRMs
- job boards
- recruiting dashboards
- internal lead generation tools
- custom backend services

***

### 🛠️ Need a Custom Scraper?

Need different fields, another job board, or a custom Apify Actor for your workflow?

I build custom scraping and automation tools for job data, ecommerce research, supplier discovery, lead generation, price monitoring, and marketplace data extraction.

Contact: **jcustombussiness@gmail.com**

Please include:

- Website URL
- Data fields you need
- Example search or listing pages
- Desired output format, such as CSV, JSON, Excel, or API
- How often you want the scraper to run

Custom scraper availability depends on website access, data availability, and technical feasibility.

***

### 📌 Summary

Google Jobs API & Job Scraper turns a job query and location into structured job listings that can be used in apps, dashboards, spreadsheets, recruiting workflows, and data products.

The main advantage of Google Jobs is that it brings together job listings from many platforms, job boards, staffing sites, and employer career pages. This actor helps you access that broad job discovery layer through a clean Apify-powered API.

Use it to search jobs faster, collect hiring data, monitor markets, discover companies that are hiring, and connect Google Jobs results to your own tools through Apify.

***

### Disclaimer

Use this actor responsibly and in compliance with Google’s terms of service and all applicable laws. Google may block automated access, and successful extraction is not guaranteed.

# Actor input Schema

## `query` (type: `string`):

Enter the job title, keyword, skill, or role you want to search for. Examples: software engineer, business analyst, registered nurse, warehouse associate.

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

Enter the city, region, state, province, or country where you want to search for jobs. Examples: Toronto Canada, Austin TX, London UK.

## `maxPages` (type: `integer`):

Maximum number of Google Jobs result pages to process. Start with 1. Higher values may return more jobs but increase blocking risk.

## `country` (type: `string`):

Choose the Google country version to use for localized job results.

## `language` (type: `string`):

Choose the Google interface language.

## `proxyGroup` (type: `string`):

Choose which proxy option to use. Residential proxies may reduce blocking if available on your Apify plan.

## `maxRetriesPerPage` (type: `integer`):

How many times to retry a page with a new session if Google blocks it.

## `requestDelayMs` (type: `integer`):

Base wait time after loading each Google page. A random extra delay is added automatically.

## `includeRawData` (type: `boolean`):

Include raw extracted data for debugging or advanced processing.

## `saveDebugFiles` (type: `boolean`):

Save HTML and screenshots when Google blocks the request or no jobs are found.

## `useApifyProxy` (type: `boolean`):

Hidden compatibility setting. Use proxyGroup instead.

## `headless` (type: `boolean`):

Run the browser without a visible window.

## `maxConcurrency` (type: `integer`):

Keep this at 1 for Google.

## `failOnNoResults` (type: `boolean`):

If disabled, the actor succeeds with an empty dataset when Google returns no results or blocks the page.

## Actor input object example

```json
{
  "query": "business analyst",
  "location": "Toronto Canada",
  "maxPages": 1,
  "country": "ca",
  "language": "en",
  "proxyGroup": "residential",
  "maxRetriesPerPage": 3,
  "requestDelayMs": 12000,
  "includeRawData": false,
  "saveDebugFiles": true,
  "useApifyProxy": true,
  "headless": true,
  "maxConcurrency": 1,
  "failOnNoResults": false
}
```

# Actor output Schema

## `title` (type: `string`):

Main job summary with company, location, salary, job type, and apply links.

## `company` (type: `string`):

Company or employer name.

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

Job location.

## `salary` (type: `string`):

Displayed salary or pay range when available.

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

Detected job type or work arrangement.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("toolsnmoreapi/google-jobs").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("toolsnmoreapi/google-jobs").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 '{}' |
apify call toolsnmoreapi/google-jobs --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Jobs Scaper",
        "description": "Search Google Jobs by job title, keyword, and location. This actor returns structured job listings with titles, companies, locations, salaries, descriptions, job types, apply links, and stable job IDs.",
        "version": "0.0",
        "x-build-id": "W2iXchkpeDILYQMke"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/toolsnmoreapi~google-jobs/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-toolsnmoreapi-google-jobs",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/toolsnmoreapi~google-jobs/runs": {
            "post": {
                "operationId": "runs-sync-toolsnmoreapi-google-jobs",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/toolsnmoreapi~google-jobs/run-sync": {
            "post": {
                "operationId": "run-sync-toolsnmoreapi-google-jobs",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query",
                    "location"
                ],
                "properties": {
                    "query": {
                        "title": "Job search query",
                        "type": "string",
                        "description": "Enter the job title, keyword, skill, or role you want to search for. Examples: software engineer, business analyst, registered nurse, warehouse associate.",
                        "default": "business analyst"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Enter the city, region, state, province, or country where you want to search for jobs. Examples: Toronto Canada, Austin TX, London UK.",
                        "default": "Toronto Canada"
                    },
                    "maxPages": {
                        "title": "Pages to scrape",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of Google Jobs result pages to process. Start with 1. Higher values may return more jobs but increase blocking risk.",
                        "default": 1
                    },
                    "country": {
                        "title": "Google country",
                        "enum": [
                            "us",
                            "ca",
                            "gb",
                            "au",
                            "in",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "br",
                            "mx"
                        ],
                        "type": "string",
                        "description": "Choose the Google country version to use for localized job results.",
                        "default": "ca"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr",
                            "es",
                            "de",
                            "it",
                            "pt",
                            "nl"
                        ],
                        "type": "string",
                        "description": "Choose the Google interface language.",
                        "default": "en"
                    },
                    "proxyGroup": {
                        "title": "Proxy option",
                        "enum": [
                            "residential",
                            "auto",
                            "none"
                        ],
                        "type": "string",
                        "description": "Choose which proxy option to use. Residential proxies may reduce blocking if available on your Apify plan.",
                        "default": "residential"
                    },
                    "maxRetriesPerPage": {
                        "title": "Retries per page",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry a page with a new session if Google blocks it.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Base request delay in milliseconds",
                        "minimum": 1000,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Base wait time after loading each Google page. A random extra delay is added automatically.",
                        "default": 12000
                    },
                    "includeRawData": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Include raw extracted data for debugging or advanced processing.",
                        "default": false
                    },
                    "saveDebugFiles": {
                        "title": "Save debug files",
                        "type": "boolean",
                        "description": "Save HTML and screenshots when Google blocks the request or no jobs are found.",
                        "default": true
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Hidden compatibility setting. Use proxyGroup instead.",
                        "default": true
                    },
                    "headless": {
                        "title": "Headless browser",
                        "type": "boolean",
                        "description": "Run the browser without a visible window.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Keep this at 1 for Google.",
                        "default": 1
                    },
                    "failOnNoResults": {
                        "title": "Fail when no results are found",
                        "type": "boolean",
                        "description": "If disabled, the actor succeeds with an empty dataset when Google returns no results or blocks the page.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
