# Google Jobs Scraper (`blueskyscraper/google-jobs-scraper`) Actor \[from $2.63/1K jobs] Scrape Google Jobs listings by job title and location: title, company, location, remote flag, job type, salary parsed into min, max, currency and period, posted date, publisher and job link. Only-new-jobs mode. No run fee. - **URL**: https://apify.com/blueskyscraper/google-jobs-scraper.md - **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community) - **Categories:** Jobs, AI, Agents - **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.80 / 1,000 jobs 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 ### Tested head-to-head — 12.10.2026 Same search for every Google Jobs actor in the top 5 by monthly users: `software engineer` in New York, 20 jobs, $0.10 spending cap. | | This Actor | Other top-5 Google Jobs actors | |---|---|---| | Jobs returned | 20 of 20 | 0–15: one returns sample (mock) jobs on the free plan, one failed, two could not run within the $0.10 cap | | Price per 1,000 jobs, free plan | $7.20 | $3 (50-job minimum) – $200 | | Price per 1,000 jobs, Gold | $2.80 | $3 – $150 | | Fields per job | 30, incl. salary as numbers, ISO date, publisher | 20–26 | | Billing | per job, a half-empty page costs half | mostly per page or with a start fee | ### What is Google Jobs Scraper? **Google Jobs Scraper** is a **Google Jobs API** for job listings. Type one or more job titles, add one or more locations, and get one row per vacancy from Google Jobs with **job title**, **company**, **location**, **remote flag**, **employment type**, the **salary text plus the salary parsed into numbers** (`salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`), the **posted date in ISO format**, the **publisher** the posting was found on (LinkedIn, ZipRecruiter, the company careers site…) and the **link to the job posting**. Every job title runs in every location you list, in one run. One row is one job. Google Jobs collects vacancies from hundreds of job boards and careers sites, so one search here covers LinkedIn, ZipRecruiter, Built In, Y Combinator, company career pages and many more at once. The data is read from Google Jobs result pages through a licensed data provider, so there are **no proxies, CAPTCHAs or browser sessions to manage** and no Google account or API key is needed on your side. - 💰 **$0.0072 per job on the free plan, from $0.0028 on paid plans — 20% cheaper than the market leader on every plan**; you pay per job, not per page, so a half-empty page costs half - 💵 **Salary data as numbers**: "125K–250K a year" becomes `125000`, `250000`, `USD`, `year` - 📅 **Posted date in ISO 8601** (`2026-09-30T00:44:28.000Z`), not just "2 days ago" - 🏠 **Remote flag** on every row, 🔁 **duplicates removed** across pages and searches - 🆕 **Only new jobs** mode for scheduled runs — jobs you already received are skipped and free - 🔗 **Same field names as our Indeed, LinkedIn and Jobs API actors** — one parser for all of them - 🆓 **Error rows are free** — an unknown location or a search with no jobs costs nothing - 🤖 Works from the **Apify API**, the **MCP server** (Claude, ChatGPT, Cursor), n8n, Make and Zapier What it does **not** return: the full job description text. Google Jobs result lists do not carry it, so this Actor does not promise it. If you need descriptions, see [Indeed Jobs Scraper](https://apify.com/lergassy/indeed-jobs-scraper) or [Jobs API](https://apify.com/lergassy/jobs-api). ### What data can Google Jobs Scraper extract? | Field | Example | What it means | |---|---|---| | 💼 `title` | `Software Engineer, Developer Infrastructure` | Job title as Google Jobs shows it | | 🏢 `company` | `Numeric` | Employer name | | 📍 `location` | `New York, NY` | Job location; `Anywhere` for remote jobs | | `otherLocationsCount` | `1` | More locations listed on the same posting ("+1 other") | | 🏠 `isRemote` | `false` | `true` when location or title says remote, anywhere or work from home | | `workplaceType` | `hybrid` | `remote`, `hybrid` or empty when the posting does not say | | ⏱️ `employmentType` | `fulltime` | Normalised: `fulltime`, `parttime`, `contractor`, `internship` | | `jobTypes` | `["fulltime"]` | All employment types the posting lists | | 💵 `salaryText` | `125K–250K a year` | Salary exactly as Google shows it | | `salaryMin` | `125000` | Lower bound as a number | | `salaryMax` | `250000` | Upper bound as a number | | `salaryCurrency` | `USD` | ISO currency code | | `salaryCurrencySource` | `search country` | `salary text` when a symbol (£, €, ₹) was in the salary; `search country` when Google left it out and the searched country's currency was used | | `salaryPeriod` | `year` | `hour`, `day`, `week`, `month` or `year` | | 📅 `postedAt` | `2026-09-14T00:34:57.000Z` | When the job was posted, ISO 8601 | | `postedText` | `18 days ago` | Posting age as Google shows it | | 🔗 `publisher` | `Built In NYC` | Site Google found the posting on | | 🔗 `url` | `https://www.builtinnyc.com/job/…` | Link to the posting (the apply page) | | `companyLogo` | `https://…/cdn/i/…:0` | Employer logo (temporary image link) | | `id` | `cdSQQAHZ24TXq-GEAAAAAA==` | Google Jobs job id | | `position` | `12` | Position in the search after duplicates are removed | | 🔍 `query` | `software engineer` | Job title you searched for | | `queryLocation` | `New York, NY` | Location as you typed it | | `searchLocation` | `New York, New York, United States` | Google Jobs location the search ran in | | `countryCode` | `US` | Country of the search | | `language` | `English` | Google interface language | | `searchUrl` | `https://www.google.com/search?q=software%20engineer&udm=8&…` | The Google Jobs search that was read | | `source` | `google-jobs` | Same field as in our other jobs actors | | `scrapedAt` | `2026-10-02T00:44:28.000Z` | When the row was produced | #### How the computed fields are made - **Salary.** Google writes salaries as short text: `250K a year`, `75–80 an hour`, `£35k–£40k a year`, `£350–£400 a day`, `£27,657–£30,730 a year`. The Actor turns K into thousands, reads ranges and single values ("From 50K" fills only `salaryMin`, "Up to $30" only `salaryMax`), detects the period and the currency. In the US Google usually drops the dollar sign, so the currency falls back to the searched country — `salaryCurrencySource` tells you which case you have. Many postings carry no salary at all; then all salary fields are empty. In our test runs 6 of 20 New York jobs and 10 of 25 London jobs had a salary. - **Posted date.** Google shows "6 hours ago" or "11 days ago"; `postedAt` turns that into a date-time. It is as precise as Google's wording (a day for "days ago"). A few postings show no age; then `postedAt` is empty. - **Remote flag.** `isRemote` is `true` when the location is "Anywhere" / "Remote" or the title says remote. It is a reading of the posting, not a promise from the employer. - **Duplicates.** The same vacancy often appears twice — once via LinkedIn and once via the company site, or under two of your job titles. Rows are de-duplicated by Google job id and by title + company + location across pages and searches of the run, so you pay for each vacancy once. ### 💰 How much does it cost to scrape Google Jobs? Google Jobs Scraper uses **pay-per-event** pricing. You pay **per job row**, nothing per run, per page or per search. | Plan | Price per job | Price per 1,000 jobs | |---|---|---| | Free | $0.0072 | $7.20 | | Bronze | $0.0036 | $3.60 | | Silver | $0.0032 | $3.20 | | Gold, Platinum, Diamond | $0.0028 | $2.80 | **How this compares:** the most-used Google Jobs actor on Apify charges per page of up to 10 jobs — $0.09 per page on the free plan and $0.045 / $0.04 / $0.035 on paid plans. Per job that is $9 / $4.50 / $4 / $3.50 per 1,000 — **we are 20% cheaper on every plan** (checked 12.10.2026). Because we bill per job rather than per page, a search that has only 4 jobs costs 4 jobs, not a full page. **What is free:** - error rows (unknown location, a search Google has no jobs for, an unsupported country); - duplicates removed by the Actor; - postings of other job types dropped by the **⏱️ Job types** filter; - jobs skipped by **🆕 Only new jobs** because an earlier run already returned them. **Examples:** the default run (10 software engineer jobs in New York) costs $0.072 on the free plan. 1,000 jobs cost $7.20 on the free plan and $2.80 on Gold. Apify's free plan includes $5 of monthly credit — about 690 jobs. ### How to scrape Google Jobs with Google Jobs Scraper 1. Open the Actor and go to the **Input** tab. 2. In **🔍 Job titles**, type one job search per line (`software engineer`, `registered nurse`, `data analyst`). 3. In **📍 Locations**, type one city, state or country per line (`New York, NY`, `London`, `Texas`, `India`). 4. Set **💯 Max jobs per search** (10 is one Google Jobs page; up to 200). 5. Optional: pick **⏱️ Job types**, switch on **🆕 Only new jobs** for scheduled runs. 6. Click **Start**. A small search finishes in 15–25 seconds. 7. Open the **Output** tab and download the table as CSV, Excel or JSON, or read it through the API. ### ⬇️ Input #### Job titles in several locations (default) ```json { "queries": ["software engineer"], "locations": ["New York, NY"], "maxJobsPerQuery": 10 } ``` Every job title runs in every location: 3 titles × 2 locations = 6 searches. Locations can be a city (`New York, NY`, `London`, `Toronto`, `Bengaluru`), a state or province (`Texas`, `Ontario`) or a country (`United States`, `UK`, `India`). Abbreviations work (`Austin, TX`, `Seattle, WA`, `NYC`). The run log prints which Google Jobs location each line was matched to, and every row carries it in `searchLocation`. #### ⏱️ Job types ```json { "queries": ["data analyst"], "locations": ["London"], "maxJobsPerQuery": 25, "jobTypes": ["fulltime", "contract"] } ``` Values: `fulltime`, `parttime`, `contract`, `internship`. Google Jobs ignores type filters sent as settings, so the Actor writes the type into the Google search itself (`marketing` + Internship → `marketing internship`) and keeps only postings labelled with a type you picked; postings of other types are dropped and not charged. Tested 12.10.2026: `marketing` + Internship in New York — 10 of 10 rows are internships (before the fix Google returned 1 internship in 10); `java developer` + Contract in the United States — 10 of 10 contract jobs. With several types picked, the Actor runs one Google search per type and mixes the answers. #### 🆕 Only new jobs ```json { "queries": ["software engineer", "software developer"], "locations": ["New York, NY"], "maxJobsPerQuery": 10, "onlyNewJobs": true } ``` The Actor remembers the jobs it returned for each job title + location + job types + language (last 5,000 per search, stored in your own Apify account). The next run returns only jobs that were not there before; the rest are skipped for free. Tested: the first run returned 20 jobs, an identical second run returned 0 and charged nothing. Schedule it daily and you get a feed of new vacancies. #### 🗣️ Language Leave empty for English (recommended: salary and date texts are then in English, which the parser reads best). Use a name or code (`German`, `de`, `es-419`) to change Google's interface language. #### Countries Google Jobs data is available for 76 countries, including the United States, United Kingdom, Canada, India, Singapore, the United Arab Emirates, Japan, Brazil, South Africa, Nigeria, Kenya, the Philippines, Malaysia and Indonesia. Tested end to end: **United States** (New York) and **United Kingdom** (London). **Not available:** Google Jobs results are currently not shown in the EU — on 2 October 2026 searches in Berlin and Paris came back empty while London and New York were full. Locations in Germany, France, Spain, Italy, the Netherlands, Belgium, Austria, Portugal, Denmark and Greece therefore return a free error row right away. Australia, New Zealand, Ireland, Mexico, Poland and the Nordics are not covered by Google Jobs data either and also get a free error row. ### ⬆️ Output One row per job: ```json { "type": "job", "source": "google-jobs", "id": "cdSQQAHZ24TXq-GEAAAAAA==", "title": "Software Engineer, Developer Infrastructure", "company": "Numeric", "location": "New York, NY", "otherLocationsCount": 0, "isRemote": false, "workplaceType": null, "employmentType": "fulltime", "jobTypes": ["fulltime"], "salaryText": "125K–250K a year", "salaryMin": 125000, "salaryMax": 250000, "salaryCurrency": "USD", "salaryCurrencySource": "search country", "salaryPeriod": "year", "postedAt": "2026-09-14T00:34:57.000Z", "postedText": "18 days ago", "publisher": "Built In NYC", "url": "https://www.builtinnyc.com/job/software-engineer-developer-infrastructure/11174118", "position": 12, "query": "software engineer", "queryLocation": "New York, NY", "searchLocation": "New York, New York, United States", "countryCode": "US", "language": "English", "scrapedAt": "2026-10-02T00:44:28.000Z" } ``` The dataset has three views: **Jobs** (the main table), **Salaries** (salary columns side by side) and **Errors**. #### Same fields as our other jobs actors `title`, `company`, `location`, `isRemote`, `workplaceType`, `employmentType`, `jobTypes`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText`, `postedAt`, `postedText`, `url`, `query`, `queryLocation`, `source` and `scrapedAt` mean the same here as in [Indeed Jobs Scraper](https://apify.com/lergassy/indeed-jobs-scraper), [LinkedIn Jobs Scraper](https://apify.com/lergassy/linkedin-jobs-scraper) and [Jobs API](https://apify.com/lergassy/jobs-api). You can append their datasets to one table and tell the rows apart by `source`. The input also accepts `keywords` and `location` as aliases of `queries` and `locations`. ### Use cases for Google Jobs data #### Job market and salary research Pull a few hundred postings for a role in several cities and compare `salaryMin` / `salaryMax` by city without retyping a single number. The Salaries view puts the parsed columns next to the original text. #### Recruiting and lead generation Agencies use hiring signals as leads: which companies are hiring for which roles right now, and through which boards. `company`, `publisher` and `postedAt` answer that in one table. #### Job alerts and new-vacancy feeds Schedule a daily run with **🆕 Only new jobs** and send the new rows to Slack, email or a Google Sheet. Already-seen jobs cost nothing. #### Job boards and aggregators Seed a niche job board with fresh postings by title and city, with links back to the original posting. #### AI agents and LLM workflows Agents can call the Actor with a title and a city and get flat rows with numeric salaries and ISO dates — easy to filter and summarise without extra parsing. ### Integrations #### Apify API (JavaScript) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('lergassy/google-jobs-scraper').call({ queries: ['registered nurse'], locations: ['Texas'], maxJobsPerQuery: 30, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items.filter((j) => j.type === 'job').map((j) => [j.title, j.company, j.salaryMin, j.salaryPeriod])); ``` #### Apify API (Python) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("lergassy/google-jobs-scraper").call(run_input={ "queries": ["data analyst"], "locations": ["London"], "maxJobsPerQuery": 25, }) for job in client.dataset(run["defaultDatasetId"]).iterate_items(): if job["type"] == "job": print(job["title"], job["company"], job["salaryMin"], job["salaryCurrency"]) ``` #### One HTTP call `POST https://api.apify.com/v2/acts/lergassy~google-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN` with the input JSON as the body returns the rows directly. #### No-code tools Use the Apify integrations for **n8n**, **Make**, **Zapier**, **Google Sheets**, **Slack** and **webhooks** to push new jobs wherever you need them. #### MCP server Add `https://mcp.apify.com` to Claude, ChatGPT, Cursor or any MCP client and ask for "software engineer jobs in New York with salaries" — the agent calls this Actor and reads the rows. ### 🤖 For AI Agents & LLM Apps Compact reference for agents calling this Actor through the Apify MCP server or the Apify API (`lergassy/google-jobs-scraper`). **Purpose:** one row per Google Jobs vacancy for a job title in a location — who is hiring, where, for what pay, since when, and the link to apply. **Minimal input:** ```json { "queries": ["software engineer"], "locations": ["New York, NY"], "maxJobsPerQuery": 10 } ``` **Output:** type, source, id, title, company, location, otherLocationsCount, isRemote, workplaceType, employmentType, jobTypes, salaryText, salaryMin, salaryMax, salaryCurrency, salaryCurrencySource, salaryPeriod, postedAt, postedText, publisher, url, companyLogo, position, query, queryLocation, searchLocation, countryCode, language, searchUrl, scrapedAt. Error rows: type "error", input, error, scrapedAt. **Behaviors an agent should know:** - Every query runs in every location; `maxJobsPerQuery` (default 10, max 200) caps each pair. - No job description text is returned. - Salary fields are empty when the posting shows no salary; `salaryCurrencySource: "search country"` means the currency was inferred. - EU countries, Australia, Ireland, Mexico and Poland return a free error row, not jobs. - Use `jobTypes` and `onlyNewJobs` instead of post-filtering: postings of other types and already returned jobs are dropped for free. - Billed per job row (event `job`); error rows, duplicates and already-seen jobs are free. - All fields are flat except `jobTypes` (array of strings). ### Error items / Troubleshooting Problems never stop the run and never cost money. They come as rows like this: ```json { "type": "error", "input": "Berlin", "error": "Google Jobs currently shows no job listings in Germany (Google Jobs results are not shown in the EU / EEA). Search a country outside the EU instead, for example United Kingdom or United States. Not charged.", "scrapedAt": "2026-10-02T00:50:20.000Z" } ``` | Error | What to do | |---|---| | Location not found | Check the spelling, add the state or country (`Cambridge, MA`, `London, UK`) | | Not a place ("Remote") | Put a country in Locations and add "remote" to the job title | | No job listings in an EU country | Google Jobs results are currently not shown in the EU; search the UK, US or another non-EU country | | Shows no jobs for this search | Try a broader title or a bigger location; with job types set, try without them | | Unknown language / job type | Use the values listed in the input form | ### ❓ FAQ #### Is it legal to scrape Google Jobs? The Actor reads publicly visible Google Jobs results — job titles, employers, locations, salaries as published by employers and job boards. It collects no personal data about candidates. Public job data is widely used for market research, but the rules depend on your country and use; consult a lawyer if you are unsure. #### Does Google Jobs Scraper return the job description? No. Google Jobs result lists do not include it. Use the `url` to open the posting, or use [Indeed Jobs Scraper](https://apify.com/lergassy/indeed-jobs-scraper) / [Jobs API](https://apify.com/lergassy/jobs-api) where descriptions are part of the row. #### How many jobs can I get per search? Up to 200 per job title and location. Google often has fewer for narrow searches; you pay only for the jobs returned. #### How fresh are the results? Each search is live at run time. An identical search repeated within 12 hours (1 hour with Only new jobs) is served from a short cache and returns the same snapshot — handy for retries, and you still get complete rows. #### Why is the salary empty? The employer did not publish one. Google shows a salary on roughly a third of postings in our tests. #### Why is the currency "search country"? Google writes US salaries as "125K–250K a year" without a dollar sign. The Actor then uses the currency of the country you searched and says so in `salaryCurrencySource`. #### How much does it cost to scrape 1,000 Google Jobs listings? $7.20 on the Apify free plan, $3.60 on Bronze, $3.20 on Silver and $2.80 on Gold and above. No start fee. #### Can I use Google Jobs Scraper with the Apify API? Yes — see the JavaScript, Python and HTTP examples above. Every input field has the same name in the API as in the JSON tab of the form. #### Can I use it through an MCP server? Yes. Connect `https://mcp.apify.com` to your AI assistant; the Actor is available as a tool and returns flat JSON rows. #### Can I integrate it with other apps? Yes: Google Sheets, Slack, n8n, Make, Zapier, Airtable and webhooks through Apify integrations. #### Do I get one row per job? Yes. One row is one vacancy; duplicates of the same job across pages, publishers and your searches are removed. #### Do I need proxies or a Google account? No. Nothing to configure beyond job titles and locations. ### Your feedback Found a location that matches the wrong place, a salary format that parses wrong, or a field you need? Open an issue in the **Issues** tab — we answer quickly and ship fixes. ### You might also like | Actor | What it does | |---|---| | [Jobs API](https://apify.com/lergassy/jobs-api) | Indeed, LinkedIn and career sites (Greenhouse, Lever, Ashby…) in one table, with descriptions | | [Indeed Jobs Scraper](https://apify.com/lergassy/indeed-jobs-scraper) | Indeed jobs with full descriptions, salaries and company data | | [LinkedIn Jobs Scraper](https://apify.com/lergassy/linkedin-jobs-scraper) | LinkedIn job listings without login | | [SEEK Jobs Scraper](https://apify.com/lergassy/seek-jobs-scraper) | Australia and New Zealand job ads from SEEK | | [Website Contacts API](https://apify.com/lergassy/website-contacts-api) | Emails and phones from company websites — pair it with `company` to reach hiring teams | # Actor input Schema ## `queries` (type: `array`): Enter one job search per line, the way you would type it into Google Jobs: a job title or a title plus a skill (software engineer, registered nurse, python developer, remote customer support). Every job title runs in every location below. keywords is accepted as an alias. ## `locations` (type: `array`): Enter one location per line: a city (New York, NY, London, Toronto, Bengaluru), a state or province (Texas, Ontario) or a country (United States, UK, India). The run log shows which Google Jobs location every line was matched to. Google no longer shows Google Jobs in the EU (Germany, France, Spain, Italy, the Netherlands…) — such lines return a free error row. Australia, Ireland, Mexico and Poland are not covered either. location is accepted as an alias. ## `maxJobsPerQuery` (type: `integer`): Set how many jobs to return for each job title in each location (1–200). Google Jobs pages hold 10 jobs; you pay only for jobs actually returned, so a search that has 34 jobs costs 34 jobs even if you ask for 200. ## `jobTypes` (type: `array`): Optional: return only these employment types. Google Jobs ignores type filters sent as settings, so the Actor adds the type to the Google search ("marketing internship") and then keeps only postings labelled with a type you picked; postings of other types are dropped for free. Leave empty for all job types. ## `onlyNewJobs` (type: `boolean`): Turn on for scheduled runs: return only jobs this Actor has not returned before for the same job title, location, job types and language (remembered in your Apify account, last 5,000 jobs per search). Jobs skipped this way are free. ## `language` (type: `string`): Optional: Google interface language, by name or code (English, en, German, de, French, fr, es-419…). Leave empty for English — salary and date texts are then in English, which the salary and date parsing understands best. ## Actor input object example ```json { "queries": [ "software engineer" ], "locations": [ "New York, NY" ], "maxJobsPerQuery": 10, "onlyNewJobs": false } ``` # Actor output Schema ## `results` (type: `string`): One row per Google Jobs vacancy: title, company, location, remote flag, employment type, salary text with parsed min / max / currency / period, posted date (ISO), publisher and job link. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "queries": [ "software engineer" ], "locations": [ "New York, NY" ], "maxJobsPerQuery": 10 }; // Run the Actor and wait for it to finish const run = await client.actor("blueskyscraper/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "queries": ["software engineer"], "locations": ["New York, NY"], "maxJobsPerQuery": 10, } # Run the Actor and wait for it to finish run = client.actor("blueskyscraper/google-jobs-scraper").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" ], "locations": [ "New York, NY" ], "maxJobsPerQuery": 10 }' | apify call blueskyscraper/google-jobs-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,blueskyscraper/google-jobs-scraper" } } } ``` 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 ` 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/thYWqwrzKMQkTkXOf/builds/RZuRjS5h9tUpcr8Gp/openapi.json