# Google Jobs API — Job Listings, Salary & Apply Links (`highbrow_fame/google-jobs-api`) Actor

Google Jobs listings as JSON for any job title, city and country: company, location, posted date, salary, job type, full description, highlights and every apply link. Unofficial Google Jobs API.

- **URL**: https://apify.com/highbrow_fame/google-jobs-api.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 job delivereds

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 API — Job Listings, Salary & Apply Links

Turn Google Jobs into clean JSON. Give the Actor a list of job titles and cities and it returns one record per posting: **title, company, location, posted date, salary (as text and as numbers), job type, the full job description, Google's own highlights (qualifications, responsibilities, benefits) and every place you can apply** — Indeed, LinkedIn, Glassdoor, the company's career site and more, with the direct ones flagged. Any country, any language, no API key, no browser to run.

**Try it in 1 minute:**

1. Press **Start** — the prefilled input searches "software engineer" and "data analyst" jobs in Austin, TX.
2. A few seconds later the **Output** tab lists the jobs with company, pay, job type, description and apply links.
3. Download JSON, CSV or Excel, call it from the API, or schedule it to watch a job market every morning.

You pay only for jobs delivered. Searches with no jobs, captcha pages and errors are **free** — they come back as a status record that says why.

**Use it to:**

- Build a **job board or job alert** without scraping a dozen job sites — Google already merges them.
- Track **salary ranges** by role and city: pay comes as text plus `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod`.
- Watch **who is hiring** for a skill or a title: company, location, posting age, and the site each posting came from.
- Feed an **AI agent or a recruiting workflow** the full job text and structured highlights instead of a screenshot of a search page.
- Compare **cities and countries** in one run: every job search is run in every location you list.

### What you get

One record per job:

| Field | What it is |
|---|---|
| `query`, `searchLocation`, `country`, `language`, `position` | What was searched, where, and the job's rank in that search |
| `jobId` | Stable id of the posting in Google Jobs |
| `title`, `company`, `location` | The job title, the hiring company and the place of the job |
| `via` | The site Google lists the posting from |
| `postedText`, `postedAgeDays`, `postedAtApprox` | "4 days ago", whole days, and an ISO time worked out from it |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | The pay as shown and as numbers (`HOUR`, `DAY`, `WEEK`, `MONTH`, `YEAR`); null when the posting shows none |
| `employmentType`, `qualification`, `remote`, `benefits[]` | Full-time / part-time / contractor, degree note, a remote flag, benefit tags |
| `description` | The posting text with line breaks. `descriptionIsPreview` is `true` when Google showed only the first lines (this happens for some sources and languages) |
| `highlights[]` | Google's extracted sections as `{ title, items[] }` — qualifications, responsibilities, benefits |
| `applyUrl`, `applyOptions[]` | The first apply link and all of them as `{ source, url, direct }` |
| `googleJobsUrl`, `companyLogo` | A link that opens the posting in Google Jobs, and the logo when shown |
| `status`, `error`, `scrapedAt` | `OK`, or `NO_RESULTS` / `FAILED` with the reason; collection time |

Phone numbers and e-mail addresses are removed from the description text.

### Input

| Field | What it does |
|---|---|
| `queries` | Job titles or keywords, one per line. Required. |
| `locations` | Cities or regions, one per line. Every job search runs in every location. Empty = no place. |
| `country` | Two-letter country code of the Google edition, default `us` (`gb`, `de`, `fr`, `ca`, `au`, `in`, ...). |
| `language` | Language code, default `en`. |
| `maxJobsPerQuery` | Jobs per search (job title in one location), 1-10, default 10. |
| `datePosted` | Any time, today, last 3 days, last week, last month. Jobs outside the period are not delivered and not charged; jobs without a date are kept. |
| `maxConcurrency` | Searches read at the same time, 1-10 (default 3). |

**Get more than ten jobs:** Google shows the ten best matches for each search, so widen the net — list several cities (`Austin, TX`, `Dallas, TX`, `Houston, TX`), several phrasings (`software engineer`, `backend developer`, `full stack developer`) or several countries in separate runs. A posting found by more than one search is delivered once per run.

### Example output

```json
{
  "query": "software engineer",
  "searchLocation": "Austin, TX",
  "position": 1,
  "title": "Associate Software Engineer",
  "company": "Charles Schwab",
  "location": "Austin, TX",
  "via": "Schwab Jobs",
  "postedText": "4 days ago",
  "salaryText": "$44.23–$45.19 an hour",
  "salaryMin": 44.23,
  "salaryMax": 45.19,
  "salaryCurrency": "USD",
  "salaryPeriod": "HOUR",
  "employmentType": "Full-time",
  "applyOptions": [
    { "source": "Schwab Jobs", "url": "https://www.google.com/goto?url=…", "direct": false },
    { "source": "Glassdoor", "url": "https://www.google.com/goto?url=…", "direct": true }
  ],
  "status": "OK"
}
```

### Good to know

- The data is what Google Jobs shows publicly for the search, in the language of the posting. Pay and job type appear only when the posting states them.
- A search that gives nothing gets one free `NO_RESULTS` record. If Google answers with a captcha page the search gets one free `FAILED` record and is not retried — the Actor never solves captchas or works around blocks. Run it again a little later.
- Apply links are Google's own redirect links; they open the application on the source site.
- This is an unofficial tool and is not affiliated with Google.

Run it on a schedule, connect it to Make, Zapier, n8n or your own code through the Apify API, or call it from an AI agent. If something looks off for a country or language, open a ticket on the **Issues** tab and say which search it was — fixes are quick.

# Actor input Schema

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

Job titles or keywords, one per line: "software engineer", "registered nurse", "data analyst remote". Each search reads the first page of Google Jobs for it.

## `locations` (type: `array`):

Cities or regions, one per line: "Austin, TX", "London", "Berlin". Every job search runs in every location, so several cities give you far more than one page of jobs. Leave empty to search without a place.

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

Two-letter country code of the Google edition: US, GB, DE, FR, CA, AU, IN, ...

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

Language of the results: en, de, fr, es, ... Job texts stay in the language of the posting.

## `maxJobsPerQuery` (type: `integer`):

Stops each search (job title in a location) after this many jobs. Google shows up to 10 per search.

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

Keep only jobs posted within this period (jobs outside it are dropped before they are charged). Jobs with no posting date are kept.

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

How many searches to read at the same time.

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

Google pages are always read through the Apify Google SERP proxy; other settings are adjusted to that.

## Actor input object example

```json
{
  "queries": [
    "software engineer",
    "data analyst"
  ],
  "locations": [
    "Austin, TX"
  ],
  "country": "us",
  "language": "en",
  "maxJobsPerQuery": 10,
  "datePosted": "any",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

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

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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",
        "data analyst"
    ],
    "locations": [
        "Austin, TX"
    ],
    "country": "us",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/google-jobs-api").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",
        "data analyst",
    ],
    "locations": ["Austin, TX"],
    "country": "us",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/google-jobs-api").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",
    "data analyst"
  ],
  "locations": [
    "Austin, TX"
  ],
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call highbrow_fame/google-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/KAzAt11uRENX9PIW2/builds/CuhnEH0sUMFGLbKr7/openapi.json