# ZipRecruiter Jobs Scraper (`khadinakbar/ziprecruiter-jobs-scraper`) Actor

Search public US ZipRecruiter listings by keyword, location, or a public search URL. Returns validated job records for talent intelligence and labor-market research.

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

## Pricing

from $5.00 / 1,000 ziprecruiter job record scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Jobs Scraper

Search public US ZipRecruiter job listings by keyword and location, or provide public ZipRecruiter search URLs. Each dataset item is a validated job record for recruitment research, hiring intelligence, salary analysis, or labor-market dashboards.

Use it when you need public job-posting data from ZipRecruiter for recruitment research, hiring intelligence, compensation analysis, or labor-market dashboards. It works best with a clear role phrase and a city/state or `Remote` location.

### What it returns

One dataset record represents one public job card. Common fields include `title`, `companyName`, `location`, `isRemote`, `employmentType`, `description`, normalized salary bounds when publicly shown, posting time, and its public ZipRecruiter route.

| Field                                  | Meaning                                                                             |
| -------------------------------------- | ----------------------------------------------------------------------------------- |
| `title`                                | Public role title                                                                   |
| `companyName`                          | Hiring organization when exposed                                                    |
| `location` / `isRemote`                | Public work location and remote indicator                                           |
| `salaryText`, `salaryMin`, `salaryMax` | Compensation shown in the listing, if any                                           |
| `description`                          | Public description or listing teaser                                                |
| `jobUrl` / `applyUrl`                  | Public ZipRecruiter job or employer-jobs route, plus an application link if exposed |
| `scrapedAt` / `sourceUrl`              | Freshness and source provenance                                                     |

### Input

```json
{
    "keywords": "senior data engineer",
    "location": "Remote",
    "maxResults": 25,
    "includeJobDetails": true
}
````

Alternatively, use `startUrls` with public ZipRecruiter **search** URLs. Search URLs override the keyword-built search. `maxResults` is always a hard cap, including when multiple URLs are provided.

### Pricing

This actor uses Pay per event + usage. It charges $0.00005 for the actor start and $0.005 for each complete, schema-valid job record written to the dataset. Apify separately reports residential-proxy and compute platform usage. The live Pricing tab is the current source of truth for charge configuration. The actor logs the maximum possible event charge before collection begins and keeps event charges within `maxResults`.

### Workflow: from a role query to a hiring decision

A talent researcher starts with a bounded query such as `data engineer` in `Remote`, then runs the actor for 25 records. Next, they compare `companyName`, `salaryMin`, `salaryMax`, and `postedAt` across the dataset to identify active employers and compensation bands. They can then export the records to a dashboard, pass the canonical `jobUrl` to an internal review workflow, or schedule the same input for a recurring market snapshot.

### Output example

```json
{
    "jobId": "zr-example-123",
    "title": "Senior Data Engineer",
    "companyName": "Example Co",
    "location": "Austin, TX",
    "isRemote": false,
    "employmentType": "FULL_TIME",
    "salaryText": "$120,000 - $160,000 annually",
    "salaryMin": 120000,
    "salaryMax": 160000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "jobUrl": "https://www.ziprecruiter.com/c/Example/Job/Senior-Data-Engineer/-in-Austin,TX",
    "applyUrl": null,
    "sourceUrl": "https://www.ziprecruiter.com/jobs-search?search=data+engineer&location=Austin%2C+TX",
    "scrapedAt": "2026-07-19T14:30:00.000Z"
}
```

### API example

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~ziprecruiter-jobs-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{"keywords":"product manager","location":"New York, NY","maxResults":20,"includeJobDetails":true}'
```

Use an `Authorization: Bearer` header instead of putting production tokens in a URL.

### AI agent prompt card

> As an AI agent, collect up to 20 public ZipRecruiter jobs for "data engineer" in Remote. Read back the resulting dataset, preserve each source URL and collection time, and summarize the title, company, location, salary fields, posting time, canonical job URL, and event cost. Keep the task within public job-listing research scope.

### Data quality and outcomes

ZipRecruiter is collected through an isolated Camoufox browser with US residential sessions, bounded retries, and one-at-a-time navigation. A valid query with an empty public result set returns `VALID_EMPTY`; input guidance is represented by `INVALID_INPUT`; target-route availability is represented by `UPSTREAM_FAILED`. Every run writes `OUTPUT` and `RUN_SUMMARY` for automation-friendly outcome readback. A `PARTIAL` outcome preserves the completed public records with contextual warnings. ZipRecruiter currently exposes many search cards through an employer-jobs route rather than an individual public detail link; in those cases `jobUrl` is that employer route and `sourceUrl` retains the exact search page.

### Best results

- Use clear role phrases and a city/state or `Remote` location.
- Start with 10–25 results to validate the query before increasing the cap.
- Keep detail enrichment on when descriptions or salary data matter; disable it for faster list-only research.
- Use canonical search URLs in `startUrls` for focused keyword and location research.

### Builder's note

I designed this actor around bounded public-job research: every persisted row is validated before its job event is charged, every result has source and collection provenance, and the run summary makes the dataset easy to interpret in downstream automation.

### Focused standalone workflow

This actor is designed as a focused standalone workflow for ZipRecruiter hiring research. Start with a single role and location, validate the returned fields, then feed the dataset into the specific dashboard, CRM, or market-analysis process that owns the next decision.

### Responsible use

Use this actor for lawful collection and analysis of publicly available job-listing data, consistent with applicable law, data-protection obligations, and ZipRecruiter's terms.

# Actor input Schema

## `keywords` (type: `string`):

Free-text terms sent to ZipRecruiter job search, such as 'senior data engineer'. Enter a role, skill, or phrase; the default is 'software engineer'. It accepts at most 120 characters. This is not a job URL or a company-only lookup.

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

Place name used with the keyword search, for example 'Austin, TX' or 'Remote'. Leave it blank to let ZipRecruiter choose its normal US search scope. The default is 'Remote'. This is not an ISO country code or a precise radius setting.

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

Optional public ZipRecruiter search URLs to scrape directly, for example 'https://www.ziprecruiter.com/jobs-search?search=data+engineer\&location=Remote'. Each URL must use a ZipRecruiter domain and overrides the keyword-built search when supplied. Leave it empty for the standard keyword mode. This is not for individual job pages or non-ZipRecruiter URLs.

## `maxResults` (type: `integer`):

Hard cap on persisted jobs and per-job event charges. Enter an integer from 1 to 100, for example 25. The default is 10 and the maximum event cost is shown before collection starts. This is not a page count and cannot produce more than 100 records.

## `includeJobDetails` (type: `boolean`):

Visit each selected public job page to improve description, compensation, and employment-type coverage when ZipRecruiter exposes it. Set true for richer records or false for faster listing-only results. The default is true. This does not bypass login, application, or account walls.

## Actor input object example

```json
{
  "keywords": "senior data engineer",
  "location": "Austin, TX",
  "startUrls": [
    {
      "url": "https://www.ziprecruiter.com/jobs-search?search=data+engineer&location=Remote"
    }
  ],
  "maxResults": 25,
  "includeJobDetails": true
}
```

# Actor output Schema

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

No description

## `output` (type: `string`):

No description

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

No description

# 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 = {
    "keywords": "software engineer",
    "location": "Remote",
    "maxResults": 10,
    "includeJobDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ziprecruiter-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 = {
    "keywords": "software engineer",
    "location": "Remote",
    "maxResults": 10,
    "includeJobDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ziprecruiter-jobs-scraper").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 '{
  "keywords": "software engineer",
  "location": "Remote",
  "maxResults": 10,
  "includeJobDetails": true
}' |
apify call khadinakbar/ziprecruiter-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/ziprecruiter-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ZipRecruiter Jobs Scraper",
        "description": "Search public US ZipRecruiter listings by keyword, location, or a public search URL. Returns validated job records for talent intelligence and labor-market research.",
        "version": "1.0",
        "x-build-id": "yenHrtmB0jjY8NnDy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~ziprecruiter-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-ziprecruiter-jobs-scraper",
                "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/khadinakbar~ziprecruiter-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-ziprecruiter-jobs-scraper",
                "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/khadinakbar~ziprecruiter-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-ziprecruiter-jobs-scraper",
                "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": {
                    "keywords": {
                        "title": "Job search keywords",
                        "type": "string",
                        "description": "Free-text terms sent to ZipRecruiter job search, such as 'senior data engineer'. Enter a role, skill, or phrase; the default is 'software engineer'. It accepts at most 120 characters. This is not a job URL or a company-only lookup.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Place name used with the keyword search, for example 'Austin, TX' or 'Remote'. Leave it blank to let ZipRecruiter choose its normal US search scope. The default is 'Remote'. This is not an ISO country code or a precise radius setting.",
                        "default": "Remote"
                    },
                    "startUrls": {
                        "title": "ZipRecruiter search URLs",
                        "type": "array",
                        "description": "Optional public ZipRecruiter search URLs to scrape directly, for example 'https://www.ziprecruiter.com/jobs-search?search=data+engineer&location=Remote'. Each URL must use a ZipRecruiter domain and overrides the keyword-built search when supplied. Leave it empty for the standard keyword mode. This is not for individual job pages or non-ZipRecruiter URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum job records",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on persisted jobs and per-job event charges. Enter an integer from 1 to 100, for example 25. The default is 10 and the maximum event cost is shown before collection starts. This is not a page count and cannot produce more than 100 records.",
                        "default": 10
                    },
                    "includeJobDetails": {
                        "title": "Include public job details",
                        "type": "boolean",
                        "description": "Visit each selected public job page to improve description, compensation, and employment-type coverage when ZipRecruiter exposes it. Set true for richer records or false for faster listing-only results. The default is true. This does not bypass login, application, or account walls.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
