# ZipRecruiter Job Real-Time Data (`b2b_leads/ziprecruiter-job-real-time-data`) Actor

Collect ZipRecruiter job listings at scale — keyword search, salary & remote filters, company jobs & URL import. Structured JSON streams in real time for recruiters, job boards, market research, salary intel & AI workflows. Fast, lightweight runs. Up to 1,000 jobs per keyword. Webhook ready.

- **URL**: https://apify.com/b2b\_leads/ziprecruiter-job-real-time-data.md
- **Developed by:** [Chidubem Aneke](https://apify.com/b2b_leads) (community)
- **Categories:** Jobs, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ZipRecruiter Job Real-Time Data

**The fastest way to collect ZipRecruiter job postings on Apify.** Turn any job search into clean, structured JSON — ready for spreadsheets, dashboards, automations, and AI workflows. Results land in your dataset **in real time**, as each job is found.

Built for recruiters, talent teams, job boards, market researchers, and builders who need **reliable hiring data at scale** — without slow setups or messy exports.

---

### Why this Actor

| | ZipRecruiter Job Real-Time Data | Typical job data tool |
|---|--------------------------------|----------------------|
| **Speed** | ~1–2 s per job | 5–15 s per job |
| **Memory** | **256–512 MB** default | 2–4 GB+ |
| **Setup** | Run in seconds | Often complex configuration |
| **Cost** | Low compute, efficient runs | High |
| **Output** | Structured JSON, LLM-ready | Often messy or incomplete |
| **Scale** | Up to **1,000 jobs** per keyword | Often capped lower |
| **Filters** | Full ZipRecruiter Jobs filters | Often keyword-only |
| **Modes** | Search · Company jobs · Job links | Usually one mode only |

---

### Three ways to collect jobs

| Mode | What it does | Best for |
|------|--------------|----------|
| **Job search** | Keyword + location search with full ZipRecruiter filters | Market scans, role tracking, location-based hiring |
| **Company jobs** | Open roles from specific employers | Competitor monitoring, account-based recruiting |
| **Job links** | Structured data from individual ZipRecruiter URLs or listing keys | Enriching a list you already have |

Enable one or combine all three in a single run.

---

### What you get — every job, fully structured

Each record is one job posting with `featureType`, `listingKey`, and `scrapedAt` so you can sort, filter, and join with your own data.

| Field | What it tells you |
|-------|-------------------|
| `title`, `company`, `location`, `workplaceType`, `isRemote` | Role, employer, place, and remote/hybrid/onsite status |
| `jobUrl`, `applyUrl`, `companyUrl`, `companyLogo` | Direct links and company branding |
| `salary`, `payMin`, `payMax`, `payCurrency`, `benefits` | Compensation signals and perks from the listing card |
| `employmentType`, `seniorityLevel`, `educationLevel` | How the role is classified |
| `snippet`, `postedTimeAgo`, `ageInDays`, `listedAtISO` | Freshness and card summary |
| `zipApply` | Whether ZipRecruiter one-click apply is available |
| `searchQuery`, `searchLocation`, `searchCompany`, `position` | Which search produced this row and its rank |
| `totalJobsCount` | Total matching jobs reported for the search |

Set `includeRaw: true` if you need extended source data for custom processing.

**`featureType` values:** `job` (search) · `company_job` (company jobs) · `scrape_by_url` (job links)

**Dataset views in Apify Console:** Overview · Compensation · Search context · Full details

---

### Search like ZipRecruiter Jobs — get data like a database

Use the **same filters job seekers use on ZipRecruiter**:

- **Keywords** — one search per keyword (e.g. `software engineer`, `registered nurse`)
- **Title** — narrow to a specific role name
- **Company** — jobs at Amazon, Capital One, or any employer
- **Skills** — technologies like Python, AWS, or React
- **Location** — New York, Texas, United States, and more
- **Experience level** — internship through executive
- **Employment type** — full-time, part-time, contract, temporary, internship
- **Workplace** — on-site, remote, hybrid
- **Date posted** — any time, past month, week, 3 days, or 24 hours
- **Salary range** — annual USD min/max filters
- **Radius** — miles around your location
- **Volume** — up to **1,000 jobs per keyword**
- **Listing card details** — salary, benefits, workplace, and apply links on every row

---

### Use cases — real outcomes

- **Recruiting pipelines** — build candidate-ready job lists by role, location, and seniority
- **Job boards and aggregators** — feed your product with fresh ZipRecruiter listings daily
- **Market and salary research** — track who is hiring, where, and at what pay ranges
- **Competitive intelligence** — monitor competitor hiring by company and function
- **Sales and BD** — spot companies in hiring mode for timely outreach
- **Staffing agencies** — track demand by region, role, and employer
- **AI assistants and agents** — summarize listings, score fit, draft outreach, or answer hiring questions
- **Data warehouses and CRMs** — push JSON into Snowflake, BigQuery, HubSpot, Airtable, or your stack via API

---

### LLM and MCP integration

Output is **structured JSON** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex, CrewAI, and custom agents. No cleanup step. No manual formatting. Just records your model can read.

#### Recommended workflow

1. Run the Actor with your keywords, companies, or job links.
2. Pull dataset items via [Apify API](https://docs.apify.com/api/v2), webhook, or export JSON/CSV.
3. Pass records to your LLM, vector store, or automation — one job per row.

#### Example: one job record for an LLM prompt

```json
{
  "featureType": "job",
  "listingKey": "019f5378-5d0c-7f2e-87d7-ce4140ceb1ef",
  "title": "Senior Software Engineer",
  "company": "Capital One",
  "location": "Manhattan, New York",
  "workplaceType": "Remote",
  "isRemote": true,
  "employmentType": "Full time",
  "salary": "USD 134,400-177,100/year",
  "payMin": 134400,
  "payMax": 177100,
  "benefits": "Medical, Vision, Dental, Paid time off, Life insurance, Retirement",
  "snippet": "Full-time · Remote · Medical, Vision, Dental",
  "postedTimeAgo": "3 days ago",
  "ageInDays": 3,
  "jobUrl": "https://www.ziprecruiter.com/job-redirect?match_token=...",
  "searchQuery": "software engineer",
  "searchLocation": "New York, NY",
  "position": 1,
  "scrapedAt": "2026-07-12T12:00:00.000Z"
}
````

#### Apify MCP (Model Context Protocol)

Connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can:

- **Run** this Actor from natural-language instructions
- **Read** job results directly in the chat
- **Chain** with other Actors — enrich contacts, send alerts, update spreadsheets

**Example MCP conversation:**

```
User: "Find 50 software engineer jobs in New York posted this week and summarize top employers"

→ MCP runs ZipRecruiter Job Real-Time Data with jobKeywords, jobLocation=New York, NY, jobDatePosted=week
→ MCP reads dataset items
→ LLM summarizes hiring trends and top companies
```

#### API quick start

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "jobKeywords": ["software engineer"],
    "jobTitle": "Software Engineer",
    "jobLocation": "New York, NY",
    "jobDatePosted": "week",
    "jobsPerQuery": 50,
    "fetchJobDetails": true
  }'
```

**Fetch results:** `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

Export as **JSON**, **CSV**, **Excel**, **RSS**, or via **API**.

***

### Input reference

#### Job search

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `jobKeywords` | string\[] | `["software engineer"]` | Search keywords — one run per keyword |
| `jobTitle` | string | — | Title filter |
| `jobCompany` | string | — | Company filter |
| `jobSkills` | string\[] | `[]` | Skills/technologies filter |
| `jobLocation` | string | `"New York, NY"` | Location |
| `jobExperienceLevels` | enum\[] | all | internship → executive |
| `jobTypes` | enum\[] | all | full\_time, part\_time, contract, temporary, internship |
| `jobRemote` | enum\[] | all | onsite, remote, hybrid |
| `jobDatePosted` | enum | `any` | any, month, week, 3days, day |
| `jobsPerQuery` | integer | `25` | Max jobs per keyword (1–1000) |
| `radiusMiles` | integer | `25` | Search radius in miles (0–500) |

#### Advanced filters

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `salaryMin` | integer | — | Annual USD pay floor |
| `salaryMax` | integer | — | Annual USD pay ceiling |
| `industryFilter` | string | — | Keep jobs whose industry contains this text |
| `educationLevels` | enum\[] | `[]` | high\_school through doctorate |
| `easyApply` | boolean | `false` | ZipApply only |
| `externalApplyOnly` | boolean | `false` | External apply only |
| `excludeListingKeys` | string\[] | `[]` | Skip known listing IDs from prior runs |

#### Company jobs

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableCompanyJobs` | boolean | `false` | Collect jobs from company profiles |
| `companyNames` | string\[] | `[]` | Company names (e.g. Amazon, FedEx) |
| `jobsPerCompany` | integer | `25` | Max jobs per company (1–1000) |

#### Job links

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableScrapeByUrl` | boolean | `false` | Collect data from individual job links |
| `scrapeUrls` | string\[] | `[]` | ZipRecruiter URLs or listing keys |

#### Output and global

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `fetchJobDetails` | boolean | `true` | Salary, benefits, workplace, apply URL on every row |
| `includeRaw` | boolean | `false` | Attach extended source data |
| `webhookUrl` | string | — | Optional URL for real-time record delivery (Zapier, Slack, CRM) |
| `webhookFormat` | enum | `json` | `json` (full record) or `slack` (message) |
| `country` | string | `us` | Target country market (us, ca, uk) |
| `maxItems` | integer | `10000` | Max total records across all modes |
| `proxyConfiguration` | object | residential US | Connection settings (US residential recommended) |

Full schema: **Input** tab on Apify Console or `.actor/input_schema.json` in this repository.

***

### Quick start examples

**Software engineer roles in New York — full details**

```json
{
  "jobKeywords": ["software engineer"],
  "jobTitle": "Software Engineer",
  "jobLocation": "New York, NY",
  "jobDatePosted": "week",
  "jobsPerQuery": 50,
  "fetchJobDetails": true
}
```

**Jobs at a specific company**

```json
{
  "jobKeywords": ["engineer"],
  "jobCompany": "Amazon",
  "jobLocation": "United States",
  "jobsPerQuery": 100
}
```

**All jobs from employer profiles**

```json
{
  "enableCompanyJobs": true,
  "companyNames": ["Amazon", "FedEx", "Capital One"],
  "jobsPerCompany": 50,
  "fetchJobDetails": true
}
```

**Import specific job links**

```json
{
  "enableScrapeByUrl": true,
  "scrapeUrls": [
    "https://www.ziprecruiter.com/jobs/j?lvk=YOUR_LISTING_KEY"
  ],
  "fetchJobDetails": true
}
```

**Remote roles with salary filter**

```json
{
  "jobKeywords": ["data engineer"],
  "jobLocation": "United States",
  "jobRemote": ["remote"],
  "salaryMin": 120000,
  "jobsPerQuery": 75,
  "fetchJobDetails": true
}
```

**High-volume market scan**

```json
{
  "jobKeywords": ["machine learning", "data scientist", "AI engineer"],
  "jobLocation": "United States",
  "jobExperienceLevels": ["mid_senior", "director"],
  "jobsPerQuery": 500,
  "fetchJobDetails": true
}
```

***

### Performance and reliability

- **Residential proxy (US recommended)** — best results and consistent throughput for US job searches.
- **Default memory: 512 MB** — enough for high-volume runs with multiple keywords and companies.
- **Streaming output** — each job is written to the dataset immediately; nothing is buffered in memory for long runs.
- **Webhook delivery** — optionally POST each new record to your URL in real time (dataset is always the primary output).
- **Spending limit aware** — respects your per-run spending cap and stops gracefully when reached.
- **Parallel processing** — multiple keywords, companies, and job links run concurrently for faster results.

***

### Limitations and compliance

- This is an unofficial tool — not affiliated with ZipRecruiter.
- Use responsibly and comply with applicable laws and ZipRecruiter's Terms of Service.
- Some fields (e.g. salary, benefits, ZipApply) appear only when employers publish them on the listing card.
- Full HTML job descriptions are not included — output focuses on structured listing card data for speed and reliability.
- Listing availability can change; expired postings may return summary data only.

***

### Contact and custom work

Need something beyond this Actor? I design and build **custom data solutions** and **full-stack products** for teams that want results — not experiments.

**Email:** <dubem115@gmail.com>\
**GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- **Custom Apify Actors** — any website, job board, or data source
- **ZipRecruiter and hiring data projects** — pipelines, alerts, and dashboards at scale
- **LLM and MCP integrations** — connect your data to ChatGPT, Claude, and agent workflows
- **Web apps and automation** — data tools, internal platforms, SaaS products, and client-facing apps
- **Any scraping project** — lead generation, market research, monitoring, and enrichment at scale

Whether you need a one-off data feed or a production system, I can help you ship it.

***

*ZipRecruiter Job Real-Time Data · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `jobKeywords` (type: `array`):

Main search terms — same as the ZipRecruiter search box. Each keyword runs as a separate paginated search (up to 1,000 jobs each).

## `jobTitle` (type: `string`):

Optional title filter combined with keywords (e.g. "Senior Software Engineer"). Leave empty to use keywords only.

## `jobCompany` (type: `string`):

Filter to a specific employer (e.g. "Amazon", "Capital One").

## `jobSkills` (type: `array`):

Technologies or skills to narrow results (e.g. "Python", "AWS", "React").

## `jobLocation` (type: `string`):

City, state, or country to search in (e.g. "New York, NY", "Texas", "United States"). Use "United States" for nationwide.

## `radiusMiles` (type: `integer`):

Distance around the location center. Set to 0 to search the full location without a radius cap.

## `jobExperienceLevels` (type: `array`):

Seniority filter sent to ZipRecruiter (internship → executive). Leave all selected for no seniority filter.

## `jobTypes` (type: `array`):

Full-time, contract, internship, etc. Leave all selected for any employment type.

## `jobRemote` (type: `array`):

On-site, remote, or hybrid. Leave all three selected for any workplace arrangement.

## `jobDatePosted` (type: `string`):

Only jobs posted within this window. When filtering by date, the shortest window is the past 24 hours.

## `jobsPerQuery` (type: `integer`):

How many unique jobs to collect per keyword (1–1,000). Pagination continues automatically until this target is reached.

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

Annual pay floor. Jobs below this range are excluded. Leave empty for no minimum.

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

Annual pay ceiling. Jobs above this range are excluded. Leave empty for no maximum.

## `industryFilter` (type: `string`):

Keep jobs whose industry field contains this text (e.g. "Technology", "Healthcare"). Case-insensitive partial match.

## `educationLevels` (type: `array`):

Keep jobs whose title or snippet mentions these education requirements. Leave empty for any education level.

## `easyApply` (type: `boolean`):

Only keep jobs with ZipRecruiter one-click apply (ZipApply).

## `externalApplyOnly` (type: `boolean`):

Only keep jobs that redirect to the employer's career site (exclude ZipApply listings).

## `excludeListingKeys` (type: `array`):

Skip known listing IDs from previous runs. Useful for incremental daily scrapes without duplicates.

## `enableCompanyJobs` (type: `boolean`):

Also search open roles at specific employers. Runs in parallel with keyword search.

## `companyNames` (type: `array`):

Employer names exactly as listed on ZipRecruiter (e.g. "Amazon", "FedEx", "Capital One").

## `jobsPerCompany` (type: `integer`):

Maximum unique jobs to collect per company name (1–1,000).

## `enableScrapeByUrl` (type: `boolean`):

Look up individual jobs by ZipRecruiter URL or listing key. Runs in addition to keyword and company search.

## `scrapeUrls` (type: `array`):

ZipRecruiter job-redirect URLs, /jobs/j?lvk= links, or raw listing key strings.

## `fetchJobDetails` (type: `boolean`):

Attach salary, benefits, job type, workplace, and apply URL on every row. Full HTML job descriptions are not included — use listing card data for fast, structured output.

## `includeRaw` (type: `boolean`):

Attach the original source payload under the raw field. Useful for custom processing; increases dataset size.

## `webhookUrl` (type: `string`):

Optional real-time push destination. Each new job row is POSTed here (Zapier, Make, Slack incoming webhook, CRM, Google Sheets).

## `webhookFormat` (type: `string`):

How each record is formatted for the webhook POST body.

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

Routes ZipRecruiter searches to the correct country market. United States and Canada are fully supported.

## `maxItems` (type: `integer`):

Hard cap on total job rows across all modes (keyword search + company jobs + URL import).

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

Residential proxy in the target country is strongly recommended for reliable, high-volume runs.

## Actor input object example

```json
{
  "jobKeywords": [
    "software engineer"
  ],
  "jobTitle": "Software Engineer",
  "jobCompany": "",
  "jobSkills": [],
  "jobLocation": "New York, NY",
  "radiusMiles": 25,
  "jobExperienceLevels": [
    "internship",
    "entry",
    "associate",
    "mid_senior",
    "director",
    "executive"
  ],
  "jobTypes": [
    "full_time",
    "part_time",
    "contract",
    "temporary",
    "internship"
  ],
  "jobRemote": [
    "onsite",
    "remote",
    "hybrid"
  ],
  "jobDatePosted": "any",
  "jobsPerQuery": 25,
  "industryFilter": "",
  "educationLevels": [],
  "easyApply": false,
  "externalApplyOnly": false,
  "excludeListingKeys": [],
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 25,
  "enableScrapeByUrl": false,
  "scrapeUrls": [],
  "fetchJobDetails": true,
  "includeRaw": false,
  "webhookUrl": "",
  "webhookFormat": "json",
  "country": "us",
  "maxItems": 10000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every job field from this run.

## `overview` (type: `string`):

Title, company, location, salary, benefits, and apply link.

## `compensation` (type: `string`):

Salary breakdown, benefits, and seniority for comp analysis.

## `searchContext` (type: `string`):

Keyword, location, position, and total available jobs per row.

## `full` (type: `string`):

All job fields including location breakdown and search metadata.

# 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 = {
    "jobKeywords": [
        "software engineer"
    ],
    "jobTitle": "Software Engineer",
    "jobCompany": "",
    "jobSkills": [],
    "jobLocation": "New York, NY",
    "radiusMiles": 25,
    "jobExperienceLevels": [
        "internship",
        "entry",
        "associate",
        "mid_senior",
        "director",
        "executive"
    ],
    "jobTypes": [
        "full_time",
        "part_time",
        "contract",
        "temporary",
        "internship"
    ],
    "jobRemote": [
        "onsite",
        "remote",
        "hybrid"
    ],
    "jobDatePosted": "any",
    "jobsPerQuery": 25,
    "industryFilter": "",
    "educationLevels": [],
    "easyApply": false,
    "externalApplyOnly": false,
    "excludeListingKeys": [],
    "enableCompanyJobs": false,
    "companyNames": [],
    "jobsPerCompany": 25,
    "enableScrapeByUrl": false,
    "scrapeUrls": [],
    "fetchJobDetails": true,
    "includeRaw": false,
    "webhookUrl": "",
    "webhookFormat": "json",
    "country": "us",
    "maxItems": 10000
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/ziprecruiter-job-real-time-data").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 = {
    "jobKeywords": ["software engineer"],
    "jobTitle": "Software Engineer",
    "jobCompany": "",
    "jobSkills": [],
    "jobLocation": "New York, NY",
    "radiusMiles": 25,
    "jobExperienceLevels": [
        "internship",
        "entry",
        "associate",
        "mid_senior",
        "director",
        "executive",
    ],
    "jobTypes": [
        "full_time",
        "part_time",
        "contract",
        "temporary",
        "internship",
    ],
    "jobRemote": [
        "onsite",
        "remote",
        "hybrid",
    ],
    "jobDatePosted": "any",
    "jobsPerQuery": 25,
    "industryFilter": "",
    "educationLevels": [],
    "easyApply": False,
    "externalApplyOnly": False,
    "excludeListingKeys": [],
    "enableCompanyJobs": False,
    "companyNames": [],
    "jobsPerCompany": 25,
    "enableScrapeByUrl": False,
    "scrapeUrls": [],
    "fetchJobDetails": True,
    "includeRaw": False,
    "webhookUrl": "",
    "webhookFormat": "json",
    "country": "us",
    "maxItems": 10000,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/ziprecruiter-job-real-time-data").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "jobKeywords": [
    "software engineer"
  ],
  "jobTitle": "Software Engineer",
  "jobCompany": "",
  "jobSkills": [],
  "jobLocation": "New York, NY",
  "radiusMiles": 25,
  "jobExperienceLevels": [
    "internship",
    "entry",
    "associate",
    "mid_senior",
    "director",
    "executive"
  ],
  "jobTypes": [
    "full_time",
    "part_time",
    "contract",
    "temporary",
    "internship"
  ],
  "jobRemote": [
    "onsite",
    "remote",
    "hybrid"
  ],
  "jobDatePosted": "any",
  "jobsPerQuery": 25,
  "industryFilter": "",
  "educationLevels": [],
  "easyApply": false,
  "externalApplyOnly": false,
  "excludeListingKeys": [],
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 25,
  "enableScrapeByUrl": false,
  "scrapeUrls": [],
  "fetchJobDetails": true,
  "includeRaw": false,
  "webhookUrl": "",
  "webhookFormat": "json",
  "country": "us",
  "maxItems": 10000
}' |
apify call b2b_leads/ziprecruiter-job-real-time-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=b2b_leads/ziprecruiter-job-real-time-data",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ZipRecruiter Job Real-Time Data",
        "description": "Collect ZipRecruiter job listings at scale — keyword search, salary & remote filters, company jobs & URL import. Structured JSON streams in real time for recruiters, job boards, market research, salary intel & AI workflows. Fast, lightweight runs. Up to 1,000 jobs per keyword. Webhook ready.",
        "version": "0.0",
        "x-build-id": "e2xEDR76MpO7UVOhP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_leads~ziprecruiter-job-real-time-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_leads-ziprecruiter-job-real-time-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/b2b_leads~ziprecruiter-job-real-time-data/runs": {
            "post": {
                "operationId": "runs-sync-b2b_leads-ziprecruiter-job-real-time-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/b2b_leads~ziprecruiter-job-real-time-data/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_leads-ziprecruiter-job-real-time-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "jobKeywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "Main search terms — same as the ZipRecruiter search box. Each keyword runs as a separate paginated search (up to 1,000 jobs each).",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTitle": {
                        "title": "Job title",
                        "type": "string",
                        "description": "Optional title filter combined with keywords (e.g. \"Senior Software Engineer\"). Leave empty to use keywords only.",
                        "default": ""
                    },
                    "jobCompany": {
                        "title": "Company",
                        "type": "string",
                        "description": "Filter to a specific employer (e.g. \"Amazon\", \"Capital One\").",
                        "default": ""
                    },
                    "jobSkills": {
                        "title": "Skills",
                        "type": "array",
                        "description": "Technologies or skills to narrow results (e.g. \"Python\", \"AWS\", \"React\").",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobLocation": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or country to search in (e.g. \"New York, NY\", \"Texas\", \"United States\"). Use \"United States\" for nationwide.",
                        "default": "New York, NY"
                    },
                    "radiusMiles": {
                        "title": "Search radius (miles)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Distance around the location center. Set to 0 to search the full location without a radius cap.",
                        "default": 25
                    },
                    "jobExperienceLevels": {
                        "title": "Experience levels",
                        "type": "array",
                        "description": "Seniority filter sent to ZipRecruiter (internship → executive). Leave all selected for no seniority filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entry",
                                "associate",
                                "mid_senior",
                                "director",
                                "executive"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-Senior",
                                "Director",
                                "Executive"
                            ]
                        },
                        "default": [
                            "internship",
                            "entry",
                            "associate",
                            "mid_senior",
                            "director",
                            "executive"
                        ]
                    },
                    "jobTypes": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Full-time, contract, internship, etc. Leave all selected for any employment type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full_time",
                                "part_time",
                                "contract",
                                "temporary",
                                "internship"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship"
                            ]
                        },
                        "default": [
                            "full_time",
                            "part_time",
                            "contract",
                            "temporary",
                            "internship"
                        ]
                    },
                    "jobRemote": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "On-site, remote, or hybrid. Leave all three selected for any workplace arrangement.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "onsite",
                                "remote",
                                "hybrid"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        },
                        "default": [
                            "onsite",
                            "remote",
                            "hybrid"
                        ]
                    },
                    "jobDatePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "month",
                            "week",
                            "3days",
                            "day"
                        ],
                        "type": "string",
                        "description": "Only jobs posted within this window. When filtering by date, the shortest window is the past 24 hours.",
                        "default": "any"
                    },
                    "jobsPerQuery": {
                        "title": "Jobs per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many unique jobs to collect per keyword (1–1,000). Pagination continues automatically until this target is reached.",
                        "default": 25
                    },
                    "salaryMin": {
                        "title": "Minimum salary (USD/year)",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Annual pay floor. Jobs below this range are excluded. Leave empty for no minimum."
                    },
                    "salaryMax": {
                        "title": "Maximum salary (USD/year)",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Annual pay ceiling. Jobs above this range are excluded. Leave empty for no maximum."
                    },
                    "industryFilter": {
                        "title": "Industry contains",
                        "type": "string",
                        "description": "Keep jobs whose industry field contains this text (e.g. \"Technology\", \"Healthcare\"). Case-insensitive partial match.",
                        "default": ""
                    },
                    "educationLevels": {
                        "title": "Education levels",
                        "type": "array",
                        "description": "Keep jobs whose title or snippet mentions these education requirements. Leave empty for any education level.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "high_school",
                                "associate",
                                "bachelor",
                                "master",
                                "doctorate"
                            ],
                            "enumTitles": [
                                "High school",
                                "Associate degree",
                                "Bachelor's degree",
                                "Master's degree",
                                "Doctorate"
                            ]
                        },
                        "default": []
                    },
                    "easyApply": {
                        "title": "ZipApply only",
                        "type": "boolean",
                        "description": "Only keep jobs with ZipRecruiter one-click apply (ZipApply).",
                        "default": false
                    },
                    "externalApplyOnly": {
                        "title": "External apply only",
                        "type": "boolean",
                        "description": "Only keep jobs that redirect to the employer's career site (exclude ZipApply listings).",
                        "default": false
                    },
                    "excludeListingKeys": {
                        "title": "Exclude listing keys",
                        "type": "array",
                        "description": "Skip known listing IDs from previous runs. Useful for incremental daily scrapes without duplicates.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "enableCompanyJobs": {
                        "title": "Company jobs",
                        "type": "boolean",
                        "description": "Also search open roles at specific employers. Runs in parallel with keyword search.",
                        "default": false
                    },
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Employer names exactly as listed on ZipRecruiter (e.g. \"Amazon\", \"FedEx\", \"Capital One\").",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobsPerCompany": {
                        "title": "Jobs per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique jobs to collect per company name (1–1,000).",
                        "default": 25
                    },
                    "enableScrapeByUrl": {
                        "title": "Import from URL",
                        "type": "boolean",
                        "description": "Look up individual jobs by ZipRecruiter URL or listing key. Runs in addition to keyword and company search.",
                        "default": false
                    },
                    "scrapeUrls": {
                        "title": "Job URLs or listing keys",
                        "type": "array",
                        "description": "ZipRecruiter job-redirect URLs, /jobs/j?lvk= links, or raw listing key strings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchJobDetails": {
                        "title": "Include listing card details",
                        "type": "boolean",
                        "description": "Attach salary, benefits, job type, workplace, and apply URL on every row. Full HTML job descriptions are not included — use listing card data for fast, structured output.",
                        "default": true
                    },
                    "includeRaw": {
                        "title": "Include extended source data",
                        "type": "boolean",
                        "description": "Attach the original source payload under the raw field. Useful for custom processing; increases dataset size.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional real-time push destination. Each new job row is POSTed here (Zapier, Make, Slack incoming webhook, CRM, Google Sheets).",
                        "default": ""
                    },
                    "webhookFormat": {
                        "title": "Webhook format",
                        "enum": [
                            "json",
                            "slack"
                        ],
                        "type": "string",
                        "description": "How each record is formatted for the webhook POST body.",
                        "default": "json"
                    },
                    "country": {
                        "title": "Country market",
                        "enum": [
                            "us",
                            "ca",
                            "uk"
                        ],
                        "type": "string",
                        "description": "Routes ZipRecruiter searches to the correct country market. United States and Canada are fully supported.",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on total job rows across all modes (keyword search + company jobs + URL import).",
                        "default": 10000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy settings",
                        "type": "object",
                        "description": "Residential proxy in the target country is strongly recommended for reliable, high-volume runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
