Google Jobs API

The Google Jobs API takes a job title and, optionally, a location, and returns the aggregated listings as rows: company, location, the board the posting came from, posting age, schedule type, the salary chip when Google shows one, and the apply link. $0.001 per delivered listing.

Get my free API key See the request

$0.001 per delivered listing · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/google_jobs/run

$ curl $QD/google_jobs/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{ "query": "data engineer",
          "location": "Berlin, Germany",
          "max_results": 30 }'
{ "status": "done", "count": 30,
  "results": [
    { "title": "Senior Data Engineer",
      "company": "Acme GmbH", "via": "via LinkedIn",
      "posted_at": "2 days ago",
      "schedule_type": "Full-time",
      "salary": "€70K–€90K", "link": "https://…" } ],
  "cost": 0.03 }
# 30 listings × $0.001 · nothing delivered, nothing charged

$0.001 / listing$1 per 1,000 delivered rows, no plan and no credit packs

Title + locationlocation optional: omit it for remote-wide searches

Up to 50 listingsper run, aggregated across boards

Salary when shownplus schedule type, posting age and source board

What the Google Jobs API returns

Google Jobs is an aggregator: it collects postings from LinkedIn, Indeed, corporate career pages and dozens of smaller boards into one list. A Google Jobs API reads that list for you and hands back typed rows. One query therefore covers many boards at once, without a scraper per board.

Google does not sell a public Jobs API, so every result on that search is somebody’s scraper — priced per request, per credit or per seat. Ours is priced per delivered listing: $0.001, which is $1 per 1,000 rows, with no subscription and no credit pack to buy first. Nothing delivered, nothing charged.

If what you need is a curated dataset rather than an endpoint — deduplicated across sources, filtered, delivered as a file — that is the job of scraping job postings on demand. This page is the endpoint: one POST, rows back, billed per row.

What comes back for every listing

Published output schema, versioned 1.0.0. Fields Google does not display on a card come back null, never invented.

Field	Type	What it holds
`title`	string	Job title as posted.
`company`	string	Employer name.
`location`	string	Location as shown on the card.
`via`	string	The board it came from ("via LinkedIn").
`posted_at`	string	Posting age chip ("2 days ago").
`schedule_type`	string	Full-time, Part-time, Contractor…
`salary`	string	Salary chip, when Google shows one.
`description`	string	Listing description snippet.
`extensions`	string[]	All badges on the card: posting age, schedule, salary, benefits.
`link`	string	Apply link — the board or the Google Jobs card.
`thumbnail` · `rank`	string · integer	Company logo and position in the result list.

Inputs: one required field

Only the query is mandatory — leave the location out and you get the query as Google resolves it, remote roles included.

Input	Type	Required	What it does
`query`	string	yes	Job title or keywords — "software engineer", "data analyst remote".
`location`	string	no	City or region — "New York, NY", "Berlin, Germany".
`country`	string	no	ISO code: exit geo and Google locale. Hiring markets differ per country.
`lang`	string	no	Interface language for the returned cards.
`max_results`	integer	no	1–50, default 10. You are billed on delivered listings only.

Pricing

What a Google Jobs API costs here

Every delivered listing costs $0.001 — $1 per 1,000 — with no monthly plan and no credit pack. Tracking 20 titles across 5 cities daily, 30 listings each, is about 3,000 rows a day: roughly $3, and less on a volume tier.

$0.001per delivered listing$1 per 1,000 delivered listings

2,000 listingson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/google_jobs/run.

# 30 data engineering roles in Berlin
curl https://api.quanticdata.io/v1/scraper/collectors/google_jobs/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "query": "data engineer", "location": "Berlin, Germany",
        "country": "de", "max_results": 30 }'

import requests

BASE = "https://api.quanticdata.io/v1/scraper/collectors"
H = {"Authorization": f"Bearer {KEY}"}

titles = ["data engineer", "machine learning engineer"]
for t in titles:
    r = requests.post(f"{BASE}/google_jobs/run", headers=H,
        json={"query": t, "location": "Berlin, Germany",
              "country": "de", "max_results": 50})
    for job in r.json()["data"]["results"]:
        print(t, "|", job["company"], job["salary"], job["via"])

const BASE = "https://api.quanticdata.io/v1/scraper/collectors";
const h = { Authorization: `Bearer ${process.env.QD_API_KEY}`,
            "Content-Type": "application/json" };

const res = await fetch(`${BASE}/google_jobs/run`, {
  method: "POST", headers: h,
  body: JSON.stringify({ query: "product manager",
                         location: "London, UK", max_results: 50 })
});
const { data } = await res.json();
// data.results[].extensions carries every badge on the card
console.log(data.count, "listings ·", data.cost, "USD");

claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, from the agent:
run_collector  slug="google_jobs"
               input={ "query": "data engineer",
                       "location": "Berlin, Germany",
                       "max_results": 30 }

What people run it for

Hiring data is a leading indicator — these are the four jobs it does best.

Hiring intelligence

Track a title in a city over time: who is hiring, how fast, at what salary band, from which board. Growth in postings usually shows up before it shows up anywhere else.

Job boards and aggregators

Seed a niche board with real listings and their apply links, refresh daily, and keep via and posted_at so you can attribute and expire rows honestly.

Salary benchmarking

The salary chip is only present on part of the market, but across thousands of rows it is enough to compare bands per title, city and schedule type.

Sales triggers

A company hiring five engineers this month is a company with budget. Pair the listings with the company data API to turn employer names into full profiles.

Collector vs job-board APIs vs your own scraper

Why people search "google jobs api" when Google does not publish one.

	Board-by-board APIs	Your own scraper	This collector
Coverage	one board per integration	whatever you built	the boards Google aggregates, in one query
Access	partner deals, approvals	blocked fast without proxies	an API key
Billing	seats or monthly minimums	proxy and compute burn	$0.001 per delivered listing
Salary & schedule	varies per board	if you parse the chips	fields on every row
Upkeep	per-integration drift	your parser breaks silently	versioned schema, hourly health check

No read API, and two products that sound like one

Google publishes nothing that returns Google for Jobs listings. Cloud Talent Solution — once the Cloud Jobs API — is a hosted search engine you populate with your own listings, and Google's structured-data guidance is about getting your postings ingested. Both are supply-side; neither reads the aggregated results.

What makes the aggregated surface worth reading is breadth: Google ingests from LinkedIn, Indeed, Glassdoor, ZipRecruiter, company career pages and hundreds of smaller boards. One query reaches sources you would otherwise integrate one at a time, and via keeps the origin board as a column so deduplication is deliberate rather than lossy.

Limits, breadth and the legal bit

Up to 50 listings per run — genuinely shallower than the board-specific collectors, because Google's own jobs list is shallow. Design for breadth: more title-and-location combinations rather than deeper paging. Google for Jobs is not enabled everywhere, so an empty result can be a fact about the market. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

extensions arrives as-is rather than forced into a rigid schema, because each source board publishes different chips and normalising them away loses information.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Google's terms restrict automated access, and descriptions are the origin employer's copyrighted text. None of this is legal advice — get some for your actual use case.

FAQ

What people ask about the Google Jobs API — because Google itself does not sell one.

Something else? Ask us →

Is there an official Google Jobs API?

No. Google indexes job postings and shows them in a jobs experience, but it does not publish a general-purpose API to read those results, which is why every option on that search is a third-party scraper. This collector is one, priced per delivered listing.

How much does a Google Jobs API cost?

Here, $0.001 per delivered listing — $1 per 1,000 — with no subscription and no credit pack. Volume tiers take up to 30% off that unit price, and the catalog endpoint returns the price your key actually pays.

Is there a free Google Jobs API?

The $2 monthly allowance covers about 2,000 delivered listings with no card, and it renews every month. After that you continue at the same unit price — nothing to unlock, no plan to upgrade to first.

Which job boards does it cover?

Whatever Google itself aggregates for that query — LinkedIn, Indeed, corporate career pages, ATS providers and smaller boards. The via field on every row tells you which source the posting came from, so you can filter or attribute per board.

Does it return the salary?

When Google shows a salary chip on the card, yes, in the salary field and inside extensions. Many postings do not publish one; those rows come back with salary: null rather than a guess.

How is this different from scraping job postings as a dataset?

This is an endpoint: you call it, rows come back, you are billed per row. Scraping job postings as a dataset is the managed version — you describe the fields and the sources, and we deliver a cleaned file. Same engine, different unit of work.

How do I deduplicate aggregated listings?

Group on company plus title plus location and use via to choose which source to keep — often the company career page rather than a board. Google aggregates, so the same role legitimately appears several times.

Where do I get structured salary?

Not here — Google surfaces whatever chip the origin board published. For parsed minimum, maximum and period, the Indeed jobs API collector structures pay properly.

Start with the Google Jobs API

$0.001 per delivered listing, $1 per 1,000 delivered listings. $2 of free credit every month, no card — and a run that delivers nothing is never billed.

Get my free API key