# Google Jobs Feed: Search Listings & Daily New Jobs (`southern-data/google-jobs-feed`) Actor

Search Google Jobs and get structured listings (title, company, salary, description, apply destinations). Optional daily new-jobs mode. About 10 newest jobs per search. Australia has no Google Jobs panel ($0). Uses Apify GOOGLE_SERP proxy.

- **URL**: https://apify.com/southern-data/google-jobs-feed.md
- **Developed by:** [Southern Data](https://apify.com/southern-data) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 job listing returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Feed: Search Listings & Daily New Jobs

Search **Google Jobs** and get structured listings — title, company, salary, job type, description, apply destinations and a Google Jobs URL. Optional **new-jobs mode** remembers what you already saw so a daily schedule only returns fresh postings.

Built for recruiters, job-board owners and researchers who need reliable Google Jobs data without surprise page charges.

### Limits (read these first)

1. **Australia has no Google Jobs panel.** If you set `country` to `au`, the run ends immediately with a clear message and **$0 charged**. Use `us`, `gb`, or another country where Google Jobs exists (or a local AU board).
2. **About 10 newest jobs per search.** Version 1 reads the first Jobs page only. Google’s `start=10` paging does not return more jobs in our tests. Combine several queries or cities instead of expecting deep pagination.
3. **Same legal grey area as any Google SERP tool.** We use Apify’s official **GOOGLE_SERP** proxy, public listings only, no login and no CAPTCHA bypass. Google’s terms still restrict automated access — you are responsible for how you use the results.
4. **Apply links are destination names, not tracking URLs.** We return `applySources` like `["Indeed","LinkedIn"]` and the Google Jobs share URL. We do **not** output Google `/goto` redirect URLs.
5. **Not every country is verified.** US and UK were probed successfully. Other countries are offered as best-effort; if Google shows no Jobs panel you still pay for the page load and get 0 jobs (except AU, which is free by design).

### Quick start

```json
{
  "queries": ["nurse jobs chicago", "data analyst jobs remote"],
  "country": "us",
  "pastDay": false,
  "mode": "all"
}
```

Daily new-jobs monitor:

```json
{
  "queries": ["nurse jobs chicago"],
  "country": "us",
  "pastDay": true,
  "mode": "new",
  "monitorName": "nurse-chicago-daily"
}
```

Schedule that input daily. First run returns the current page of jobs (all marked new). Later runs return only listings not seen before.

### Output fields

| Field | Meaning |
|---|---|
| `title`, `company`, `jobLocation`, `via` | Listing basics |
| `postedAge`, `salary`, `jobType` | When Google shows them |
| `highlights`, `description` | From the listing detail (when present) |
| `applySources`, `applyDirectLabel` | Where Google says to apply |
| `googleJobUrl`, `jobId` | Share URL and stable id (`htidocid`) |
| `isNew` | Set in `mode=new` |
| `query`, `country`, `searchUrl`, `checkedAt` | Provenance |

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `actor-start` | $0.005 | Once per run, after the first successful Google page load |
| `page-check` | $0.01 | Each Google Jobs page loaded |
| `job` | $0.001 | Each job row returned |

**Store discount tiers:** free-plan and Bronze users pay the prices above. Silver gets 10% off and Gold (and higher) gets 20% off.

**Free:** invalid input (exit 0), Australia / known no-panel short-circuit, failed page loads, jobs filtered out as already-seen in `mode=new`, duplicates across queries in the same run.

Typical cost for one US search returning 10 jobs: **$0.005 + $0.01 + 10×$0.001 = $0.025**.

### Tips

- Prefer many focused queries (`"python developer austin"`, `"python developer denver"`) over one broad query plus pagination.
- Turn on `pastDay` for monitors so you mostly see fresh posts.
- Set `monitorName` and keep it stable when using Apify Schedules.
- Default memory is 512 MB — enough for this actor.

### Self-test

Set `"selfTest": true` to run offline parser checks plus one live US Jobs page. Used by our daily health schedule.

# Actor input Schema

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

Job searches, one per line — the words people type into Google Jobs, e.g. "nurse jobs chicago" or "data analyst remote". Each query loads one Google Jobs page (~10 newest listings). Version 1 does not paginate deeper.

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

Which Google Jobs country to search. <b>Australia (au) has no Google Jobs panel</b> — the run ends with a clear message and $0 charged. Confirmed working: United States, United Kingdom.

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

Optional place Google should bias toward, e.g. "Chicago, IL" or "London". Leave empty to use the country only.

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

Google interface language code (hl), e.g. en, de, fr. Defaults to the country's usual language.

## `pastDay` (type: `boolean`):

Adds Google's "past day" filter (tbs=qdr:d). Recommended for daily monitors.

## `mode` (type: `string`):

all = return every job found on the page. new = return only jobs not seen in earlier runs (uses a key-value store; set monitorName for scheduled runs).

## `monitorName` (type: `string`):

Stable name for the seen-jobs memory, e.g. "nurse-chicago-daily". Use the same name on every scheduled run. If empty, memory is keyed from your queries and resets when they change.

## `maxJobs` (type: `integer`):

Hard cap on rows returned (and charged) in this run. Default 200. Each query only yields about 10 jobs in v1.

## `includeDescription` (type: `boolean`):

When on, each row includes Google's job highlights and the short description when present. Turn off for smaller output.

## `selfTest` (type: `boolean`):

Offline parser checks plus one live US Google Jobs page. For the publisher's daily health check. Leave off for normal use.

## Actor input object example

```json
{
  "queries": [
    "nurse jobs chicago",
    "data analyst jobs remote"
  ],
  "country": "us",
  "pastDay": false,
  "mode": "all",
  "maxJobs": 200,
  "includeDescription": true,
  "selfTest": false
}
```

# Actor output Schema

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

One row per job listing returned. Views: Jobs overview.

## `queries` (type: `string`):

QUERIES record: per search query, pages loaded, jobs found/returned, errors, search link.

## `runSummary` (type: `string`):

RUN_SUMMARY record: pages loaded/failed, jobs returned, charged events, settings, any input problem.

## `selfTest` (type: `string`):

SELF_TEST record: only present when the Actor runs with selfTest: true.

# 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": [
        "nurse jobs chicago",
        "data analyst jobs remote"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("southern-data/google-jobs-feed").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": [
        "nurse jobs chicago",
        "data analyst jobs remote",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("southern-data/google-jobs-feed").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": [
    "nurse jobs chicago",
    "data analyst jobs remote"
  ]
}' |
apify call southern-data/google-jobs-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,southern-data/google-jobs-feed"
        }
    }
}
```

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/ZQnGPZyLTamoOTWDg/builds/8ikZht08198fhNsgA/openapi.json