# SEEK Jobs Scraper — Seek, JobStreet & Jobsdb (8 countries) (`pampadata/seek-jobs-scraper`) Actor

Every job of a search on Seek (Australia, New Zealand), JobStreet (Indonesia, Malaysia, Philippines, Singapore) and Jobsdb (Hong Kong, Thailand), past Seek's ~500-job stop: salary as numbers, applicants, contact details removed, and a 'Seek says N, delivered N' check.

- **URL**: https://apify.com/pampadata/seek-jobs-scraper.md
- **Developed by:** [Cowboi Bebot](https://apify.com/pampadata) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

Every job of a search on **Seek** (Australia, New Zealand), **JobStreet** (Indonesia, Malaysia, Philippines, Singapore) and **Jobsdb** (Hong Kong, Thailand), all eight boards of the SEEK platform in one Actor. It goes past the point where Seek stops listing (about 500 jobs per search), and each search ends with a plain check: **how many jobs Seek says exist, and how many you received.**

*Versión en español más abajo.*

### Quick facts

- **What it does:** Every job of a search on the eight SEEK-platform boards (Seek AU/NZ, JobStreet ID/MY/PH/SG, Jobsdb HK/TH), past Seek's ~500-jobs-per-search stop, with salary as numbers and optional full ad details.
- **Use it for:** job-market data for Australia, New Zealand and South-East Asia: counts, salaries, applicants, companies hiring; daily job feeds.
- **Not for:** recruiters' phone numbers or contact fields (never requested; e-mails and phones are removed from the ad text); job sites outside the SEEK platform.
- **Input:** `searches` (words as typed on Seek) and/or `startUrls` (Seek/JobStreet/Jobsdb search or job links); `countries` (AU, NZ, ID, MY, PH, SG, HK, TH; default AU). Optional filters: `location`, `classifications`, `workTypes`, `workArrangements`, `postedWithinDays`, `salaryMin`/`salaryMax`/`salaryType`, `sortBy`; `maxJobsPerSearch` (default 100, 0 = all); `includeDetails` (default off).
- **Output:** one dataset row per job, and one `SUMMARY` record with "Seek says N, delivered N" per search. Every field with its type is under *Output reference* below.
- **Charged events (pay per event):** `job` USD 0.001 per job delivered (USD 1.00 per 1,000); `job-with-details` USD 0.0015 per job delivered with details (USD 1.50 per 1,000; a job whose details Seek did not return is charged as `job`); plus Apify's standard start event `apify-actor-start`.
- **Never charged:** searches as such (there is no fee per search), searches that find nothing or fail, duplicates (a job found by two searches is charged once), the SUMMARY record.
- **Limits:** stops at `maxJobsPerSearch` or at your maximum charge per run (SUMMARY `stoppedBy`); Seek's own count is an estimate, so a small gap is normal; parts Seek would not list in full are named in `incompleteParts`.
- **Run it from:** Apify Console, the Apify API or an AI agent through the Apify MCP server (Actor `pampadata/seek-jobs-scraper`), with schedules and integrations.

#### Minimal input

A small input that works, taken from this Actor's own tests; every other field is optional:

```json
{
  "searches": [
    "python developer"
  ],
  "countries": [
    "AU"
  ],
  "maxJobsPerSearch": 5
}
```

### Past Seek's 500-job stop

Seek Australia and New Zealand stop every search at about 500 jobs, even when the page says there are thousands. When that happens, this Actor splits the search by itself (classification, then sub-classification, work type, work arrangement and state or region) and merges the parts without duplicates. Tests on 2026-10-08:

| Search | Seek says | One plain search | This Actor |
|---|---|---|---|
| python, Australia | 1,537 | 490 | 1,531 |
| nurse, Australia | 8,914 | about 500 | 8,713 |
| nurse, New Zealand | 1,163 | about 500 | 1,139 |

Seek's own count is an estimate (it changes with the page size), so a small gap is normal. The JobStreet and Jobsdb sites page to the end without splitting.

### What you can search

- **Search words**, one per line, as you would type them on Seek: `data analyst`, `nurse`. Each one runs on every country you pick.
- **Links** copied from any of the eight sites: a search results page (its filters are used as they are) or a single job.
- Filters: location (`Sydney NSW`, `All Auckland`, `Kuala Lumpur`), classification, work type, work arrangement (on-site, hybrid, remote), listed in the last 1–31 days, salary range (Seek's own filter), relevance or newest first.
- Leave the words empty and pick a location or classification to get every job that matches them.

### What you get for each job

- Job ID and link, title, company, advertiser name and ID, company profile link
- Site and country, location, classification and sub-classification (names and IDs)
- Work type, work arrangement, salary as written, and **salary as numbers**: minimum, maximum, currency and period (`"$150,000 – $170,000 + 12% super"` gives 150,000–170,000, not 12)
- Date listed, teaser, bullet points, logo link, featured or not

With **Include job details** turned on, you also get:

- Full ad text (plain text and HTML)
- **Number of applicants** and Seek's application-volume label, where Seek shows them
- Suburb, region, state, postcode
- Expiry date, status, whether you apply on an external site
- Screening questions
- Company industry, size, website, rating and review count

#### Example (with details, trimmed)

```json
{
  "jobId": "95150946",
  "url": "https://sg.jobstreet.com/job/95150946",
  "title": "Accountant",
  "company": "Fast Flow Systems Pte Ltd",
  "site": "SG",
  "country": "Singapore",
  "location": "Bukit Timah, Central Region",
  "classification": "Accounting",
  "subClassification": "Management Accounting & Budgeting",
  "workTypes": ["Full time"],
  "salaryText": "$4,500 – $5,500 per month",
  "salaryMin": 4500,
  "salaryMax": 5500,
  "salaryCurrency": "SGD",
  "salaryPeriod": "MONTH",
  "listedAt": "2026-10-08T14:34:22Z",
  "applicantCount": 39,
  "applicationVolume": "Medium application volume",
  "expiresAt": "2026-11-08T12:59:59.999Z",
  "screeningQuestions": ["What's your expected monthly basic salary?", "..."],
  "companyIndustry": "Electricity, Gas & Water Services",
  "companySize": "51-100 employees",
  "detailsError": null
}
```

### The "Seek says N, delivered N" check

The **SUMMARY** record in the run's key-value store lists every search with: Seek's count, how many jobs you got, whether the search is complete, how many smaller searches it took, duplicates skipped (a job found by two of your searches is delivered and billed once), and the reason if it stopped early (your *Max jobs per search*, your spending limit, a part Seek would not list in full, or an error). It is saved as the run goes, so a run stopped by its timeout still says what it got.

### Pricing

You pay only for jobs delivered. There is no fee per search and nothing for an empty or failed search.

- **Job: USD 1.00 per 1,000** (USD 0.001 each)
- **Job with details: USD 1.50 per 1,000** (USD 0.0015 each). If Seek returns no details for a job, it is billed as a plain job.
- Apify also bills its standard tiny start event (USD 0.00005 per run, per GB of memory).

The Actor stops cleanly at your *maximum cost per run*, and the SUMMARY record says where it stopped. *Max jobs per search* starts at 100; set it to 0 to get all of them.

### Good to know

- Seek's keyword search is broad: for "java", many jobs returned do not contain the word. That is how the site searches; this Actor returns what Seek returns.
- The location box works across sites ("Sydney NSW" on JobStreet Singapore returns Sydney jobs), so each row's `country` comes from the job itself, not from the site.
- A few Australian jobs are placed at "All Australia" with no state; the Actor makes an extra pass to reach them, and the SUMMARY record lists any part it still could not get in full.
- Leave the proxy setting as it is. In tests Seek never blocked Apify's datacenter IPs; if it ever does, the run moves to residential IPs by itself at no extra cost to you.

### Personal data

The Actor does not collect recruiters' phone numbers or contact fields, and it **removes e-mail addresses and phone numbers from the ad text** (`[email removed]`, `[phone removed]`). About one ad in four carries one. What remains is about jobs and companies. If you store names that appear in an ad, data-protection law may apply to you. This Actor is not affiliated with, endorsed by or sponsored by SEEK. Seek, JobStreet and Jobsdb are trademarks of SEEK Limited.

### Questions or a missing feature?

Open an issue in the **Issues** tab. Answers come in writing.

### Output reference

#### Dataset: one row per job

| Field | Type | What it is |
|---|---|---|
| `jobId` | string | Seek's job ID. |
| `url` | string | Link to the job on its site. |
| `title` | string | Job title. |
| `company` | string | Company name shown on the ad. |
| `advertiserName` | string | Advertiser (may be a recruiter). |
| `advertiserId` | string | Advertiser ID. |
| `companyProfileUrl` | string or null | Company profile link on the site, when there is one. |
| `site` | string | Board the job was read from: AU, NZ, ID, MY, PH, SG, HK, TH. |
| `country` | string | Country of the job itself (the location box works across sites). |
| `location` | string | Location as written on the ad. |
| `locations` | array of string | All location labels of the ad. |
| `classification` | string | Classification name, e.g. Accounting. |
| `classificationId` | string | Classification ID. |
| `subClassification` | string | Sub-classification name. |
| `subClassificationId` | string | Sub-classification ID. |
| `workTypes` | array of string | Work types as Seek labels them (full time, part time, contract/temp, casual). |
| `workArrangement` | string or null | On-site, Hybrid or Remote, when given. |
| `salaryText` | string or null | Salary as written. |
| `salaryMin` | integer or null | Salary minimum as a number ("$150,000 – $170,000 + 12% super" gives 150000). |
| `salaryMax` | integer or null | Salary maximum as a number. |
| `salaryCurrency` | string or null | ISO currency code, e.g. AUD, SGD. |
| `salaryPeriod` | string or null | e.g. YEAR, MONTH, HOUR. |
| `listedAt` | string | Date listed (ISO 8601, UTC). |
| `teaser` | string | Short summary of the ad. |
| `bulletPoints` | array of string | The ad's bullet points. |
| `logoUrl` | string or null | Company logo link. |
| `isFeatured` | boolean | Featured (paid placement) on the list. |
| `roleId` | string | Seek's role identifier. |
| `search` | string | The search this job came from. |
| `descriptionHtml` | string | Only with includeDetails: full ad text as HTML (e-mails and phones removed). |
| `descriptionText` | string | Only with includeDetails: full ad text as plain text (e-mails and phones removed). |
| `contactDetailsRemoved` | integer | Only with includeDetails: e-mail addresses and phone numbers removed from the text. |
| `status` | string | Only with includeDetails: Seek's job status. |
| `isExpired` | boolean | Only with includeDetails: whether the job has expired. |
| `expiresAt` | string | Only with includeDetails: expiry date (ISO 8601). |
| `appliesOnExternalSite` | boolean | Only with includeDetails: you apply on another site. |
| `isVerified` | boolean | Only with includeDetails: Seek's verified flag for the job. |
| `advertiserVerified` | boolean or null | Only with includeDetails: Seek's verified flag for the advertiser. |
| `advertiserSince` | string | Only with includeDetails: advertiser registration date. |
| `applicantCount` | integer or null | Only with includeDetails: number of applicants, where Seek shows it. |
| `applicantCountText` | string or null | Only with includeDetails: Seek's applicant label. |
| `applicationVolume` | string or null | Only with includeDetails: Seek's application-volume label. |
| `suburb` | string or null | Only with includeDetails: suburb. |
| `region` | string or null | Only with includeDetails: region. |
| `state` | string or null | Only with includeDetails: state. |
| `postcode` | string or null | Only with includeDetails: postcode. |
| `normalisedTitle` | string | Only with includeDetails: Seek's normalised role title. |
| `screeningQuestions` | array of string | Only with includeDetails: the employer's screening questions. |
| `companyIndustry` | string or null | Only with includeDetails: company industry. |
| `companySize` | string or null | Only with includeDetails: company size. |
| `companyWebsite` | string or null | Only with includeDetails: company website. |
| `companyRating` | number or null | Only with includeDetails: company rating on Seek. |
| `companyReviewCount` | integer or null | Only with includeDetails: number of company reviews. |
| `companyTags` | array of string | Only with includeDetails: Seek's company tags. |
| `detailsError` | string or null | Only with includeDetails: null when the details came; the error when they did not (that row is charged as `job`). |

#### SUMMARY record (run's key-value store, never charged)

| Field | Type | What it is |
|---|---|---|
| `searches` | array of object | One item per search and site (fields below). |
| `jobsDelivered` | integer | Jobs delivered in the run. |
| `requests` | object | Request counters of the run (requests, retries, refusals or blocks, failures; whether the run moved to residential IPs). |
| `proxy` | string | Proxy mode of the run. |

Each item of `searches`:
| Field | Type | What it is |
|---|---|---|
| `input` | string | Your search words or link. |
| `site` | string | Board searched. |
| `seekSays` | integer or null | Seek's own count (an estimate). |
| `delivered` | integer | Jobs delivered (and charged) for this search. |
| `duplicatesSkipped` | integer | Jobs already delivered by another search of the run. |
| `complete` | boolean | true when the search was read in full. |
| `stoppedBy` | string or null | Why it stopped early (maxJobsPerSearch, your maximum charge, a part Seek would not list in full, an error). |
| `slicesSearched`, `splits` | integer | Smaller searches it took to get past the ~500 stop. |
| `incompleteParts` | array of object | Parts Seek would not list in full: filters, seekSays, reached. |
| `detailsFailed` | integer | With includeDetails: jobs whose details did not come. |
| `warning` | string | e.g. Seek does not recognise the location. |
| `errors` | array of string | Errors met. |

### More Actors by this developer

- [Google Ads Transparency Scraper](https://apify.com/pampadata/google-ads-transparency-scraper)
- [Career Site Jobs Scraper (Workday, Greenhouse, Lever and 6 more)](https://apify.com/pampadata/career-site-jobs-scraper)
- [AliExpress Search Scraper](https://apify.com/pampadata/aliexpress-search-scraper)
- [Google News Scraper](https://apify.com/pampadata/google-news-scraper)
- [Sports Odds vs Prediction Markets (Kalshi, Polymarket)](https://apify.com/pampadata/sports-odds-vs-prediction-markets)
- [Google Trends Scraper](https://apify.com/pampadata/google-trends-scraper)
- [YouTube Transcripts in Bulk (whole channels, playlists)](https://apify.com/pampadata/youtube-transcripts-bulk)

***

### Versión en español

Todos los avisos de una búsqueda en **Seek** (Australia, Nueva Zelanda), **JobStreet** (Indonesia, Malasia, Filipinas, Singapur) y **Jobsdb** (Hong Kong, Tailandia): las ocho bolsas de la plataforma SEEK en un solo programa. Pasa el corte de Seek (unos 500 avisos por búsqueda) y cada búsqueda termina con un control simple: **cuántos avisos dice Seek que hay y cuántos recibiste.**

#### De un vistazo

- **Qué hace:** Todos los avisos de una búsqueda en las ocho bolsas de la plataforma SEEK (Seek AU/NZ, JobStreet ID/MY/PH/SG, Jobsdb HK/TH), más allá del corte de ~500 por búsqueda, con el sueldo como números y detalles opcionales.
- **Sirve para:** datos del mercado laboral de Australia, Nueva Zelanda y el sudeste asiático: cantidades, sueldos, postulantes, empresas que contratan; feeds diarios.
- **No sirve para:** teléfonos o datos de contacto de reclutadores (nunca se piden; se borran correos y teléfonos del texto); bolsas fuera de la plataforma SEEK.
- **Entrada:** `searches` (palabras como en Seek) y/o `startUrls` (enlaces de búsqueda o de aviso); `countries` (AU por defecto). Filtros opcionales: lugar, clasificación, tipo de trabajo, modalidad, días, sueldo, orden; `maxJobsPerSearch` (100 por defecto, 0 = todos); `includeDetails` (apagado). Ejemplo mínimo en JSON: sección *Minimal input* de la parte en inglés.
- **Salida:** una fila por aviso y un registro `SUMMARY` con "Seek dice N, entregados N" por búsqueda.
- **Eventos que se cobran:** `job` USD 0,001 por aviso (USD 1,00 cada 1.000); `job-with-details` USD 0,0015 por aviso con detalles (USD 1,50 cada 1.000; sin detalles se cobra como `job`); más `apify-actor-start`.
- **Nunca se cobra:** las búsquedas en sí (no hay cargo por búsqueda), búsquedas vacías o fallidas, repetidos, el registro SUMMARY.
- **Límites:** se detiene en `maxJobsPerSearch` o en tu costo máximo por corrida (`stoppedBy` en SUMMARY).

#### El corte de los 500

Seek Australia y Nueva Zelanda cortan toda búsqueda cerca de 500 avisos, aunque digan que hay miles. Cuando pasa, el programa divide la búsqueda solo (clasificación, subclasificación, tipo de trabajo, modalidad y estado o región) y junta las partes sin duplicados. Pruebas del 2026-10-08: python en Australia, 1.531 de 1.537 (una búsqueda sola: 490); nurse en Australia, 8.713 de 8.914; nurse en Nueva Zelanda, 1.139 de 1.163. El número de Seek es una estimación, así que una diferencia chica es normal.

#### Qué podés buscar

Palabras (una por línea, se corren en cada país elegido), enlaces copiados de cualquiera de los ocho sitios (búsqueda o aviso), y filtros: lugar, clasificación, tipo de trabajo, modalidad (presencial, híbrido, remoto), publicados en los últimos 1 a 31 días, rango de sueldo y orden. Sin palabras y con un lugar o clasificación, trae todos los avisos que coinciden.

#### Qué recibís

Por cada aviso: ID y enlace, puesto, empresa, anunciante, país y lugar, clasificación, tipo de trabajo, modalidad, sueldo como está escrito y **como números** (mínimo, máximo, moneda y período), fecha y resumen. Con **Include job details** además: texto completo, **cantidad de postulantes** donde Seek la muestra, barrio, estado y código postal, vencimiento, preguntas de filtro y datos de la empresa (rubro, tamaño, sitio, calificación).

El registro **SUMMARY** dice, por cada búsqueda, cuántos avisos informa Seek, cuántos recibiste, si está completa y, si se cortó antes, por qué.

#### Precio

Pagás solo por aviso entregado; nada por búsqueda ni por búsquedas vacías o fallidas.

- **Aviso: USD 1,00 cada 1.000**
- **Aviso con detalles: USD 1,50 cada 1.000** (si Seek no devuelve detalles, se cobra como aviso común)
- Más el evento de inicio estándar de Apify (USD 0,00005 por corrida, por GB de memoria).

El programa se detiene en tu *costo máximo por corrida* y lo informa en SUMMARY. *Max jobs per search* viene en 100; poné 0 para traer todos.

#### Datos personales

No se piden los teléfonos ni los datos de contacto de los reclutadores, y **se borran los correos y teléfonos del texto del aviso**. Este programa no está afiliado a SEEK ni cuenta con su respaldo.

¿Dudas o algo que falta? Abrí un *issue* en la pestaña **Issues**; se responde por escrito.

# Actor input Schema

## `searches` (type: `array`):

One search per line, as you would type it on Seek ("data analyst", "nurse"). Each one runs on every country you pick below. Leave empty to take every job that matches the location or classification filters.

## `countries` (type: `array`):

Board codes: AU, NZ (Seek), ID, MY, PH, SG (JobStreet), HK, TH (Jobsdb). Default AU. All eight boards run on the same SEEK platform, so one run can cover several.

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

As written on the site: "Sydney NSW", "All Melbourne VIC", "Auckland", "Kuala Lumpur". Empty = the whole country.

## `classifications` (type: `array`):

Optional. Same list on all eight sites.

## `workTypes` (type: `array`):

Optional. Full time, part time, contract/temp, casual.

## `workArrangements` (type: `array`):

Optional. On-site, hybrid or remote.

## `postedWithinDays` (type: `string`):

Only jobs listed in this many days.

## `salaryMin` (type: `integer`):

Seek's own salary filter, in the local currency. It also uses salary ranges that advertisers hide from the ad.

## `salaryMax` (type: `integer`):

Empty = no upper limit.

## `salaryType` (type: `string`):

Which period the salary filter uses (Seek: usually per year; JobStreet and Jobsdb: per month).

## `sortBy` (type: `string`):

Relevance (Seek's default) or newest first.

## `startUrls` (type: `array`):

A search results link copied from the site (its filters are used as they are), or a single job link.

## `maxJobsPerSearch` (type: `integer`):

0 = all of them. When Seek stops a search near 500 jobs, the run splits it into smaller searches by itself to get the rest.

## `includeDetails` (type: `boolean`):

One extra request per job: full ad text, number of applicants, suburb/state/postcode, expiry date, screening questions, company industry, size and rating. Billed at the 'job with details' price.

## `detailConcurrency` (type: `integer`):

How many job details to fetch at the same time.

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

Leave as is: the run uses Apify's datacenter IPs and moves by itself to residential IPs if the site starts blocking them. If you pick proxy groups or your own proxies, they are used as given.

## Actor input object example

```json
{
  "searches": [
    "data analyst"
  ],
  "countries": [
    "AU"
  ],
  "postedWithinDays": "0",
  "salaryType": "annual",
  "sortBy": "RELEVANCE",
  "maxJobsPerSearch": 100,
  "includeDetails": false,
  "detailConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

Dataset items: one row per job delivered (jobId, url, title, company, site, country, location, classification, workTypes, salaryText and salary as numbers, listedAt…; with includeDetails also the full text, applicants, expiry, screening questions, company data, detailsError). Charged per row: event `job` or `job-with-details`.

## `summary` (type: `string`):

Key-value record SUMMARY: per search, seekSays vs delivered, complete, stoppedBy, splits, incompleteParts, duplicatesSkipped; run total jobsDelivered and request counters. Not charged.

# 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 = {
    "searches": [
        "data analyst"
    ],
    "countries": [
        "AU"
    ],
    "maxJobsPerSearch": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("pampadata/seek-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searches": ["data analyst"],
    "countries": ["AU"],
    "maxJobsPerSearch": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("pampadata/seek-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 '{
  "searches": [
    "data analyst"
  ],
  "countries": [
    "AU"
  ],
  "maxJobsPerSearch": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call pampadata/seek-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pampadata/seek-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 <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/Ix6vb30moEsvc1x18/builds/O0FqpAFiDDVbrR2vB/openapi.json