# Indeed Jobs Scraper — Job Listings & Salary Data API (No Key) (`logiover/indeed-jobs-scraper`) Actor
Keyless job-listings API in the spirit of Indeed — no login, no Cloudflare walls. Aggregates thousands of fresh openings from public job-board APIs plus real Indeed postings from the public web archive. Filter by keyword, location, remote, type and salary. Export to JSON, CSV or Excel.
- **URL**: https://apify.com/logiover/indeed-jobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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
## Indeed Jobs Scraper — Job Listings, Salary & Company Data API (No API Key)
    
An **Indeed jobs scraper** and structured **job-listings data API** in a single Apify Actor. Pull thousands of fresh job postings — title, company, location, salary, remote flag, job type, tags and full description — and **export job data to JSON, CSV or Excel** for recruiting, lead generation, salary benchmarking and labour-market analytics. **No API key, no login, no cookie, no Cloudflare walls.**
> ### 🏆 How it works (read this first — it's the honest bit)
> Indeed's own website is protected end-to-end by Cloudflare Turnstile and returns `403` to any keyless, self-contained scraper. So this Actor **does not hammer indeed.com live** — that approach is blocked for everyone without a paid unblocker. Instead it delivers the same kind of data, **keyless and ToS-clean**, through two engines:
>
> - **`live` (default)** — aggregates fresh openings from four public **job-board developer APIs** (Arbeitnow, RemoteOK, Jobicy, Himalayas), normalizes them into **one unified schema**, de-duplicates across sources, and filters by your keyword / location / remote / type / salary. A single run easily returns **500 – 1,000+ jobs**.
> - **`indeedArchive`** — pulls **real Indeed job postings** from the **public web archive** (`web.archive.org`, which is *not* behind Indeed's Cloudflare), parsing the `JobPosting` JSON-LD and Indeed's own job-cards data out of archived snapshots.
>
> You get Indeed-style job data with **zero API keys and zero blocked requests**. This README never claims to live-scrape indeed.com — because nobody can do that keyless, and honesty beats a broken promise.
---
### ✨ What this Actor does / Key features
- 💼 **Thousands of fresh jobs per run** — the `live` engine paginates four keyless job feeds and aggregates them into one dataset. Empty input alone returns **500+** current openings.
- 🧭 **Filter like Indeed** — by **keyword** (title / skill / role), **location** (city, region, country or `remote`), **remote-only**, **job type** (full-time / part-time / contract / temporary / internship), **date posted** and **minimum salary**.
- 💰 **Real salary data** — `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` as **real numbers**, plus a human-readable `salaryText`, wherever the source publishes pay.
- 🏢 **Company + logo** — `company`, `companyLogo`, and a clickable `applyUrl` / `jobUrl` on every row.
- 🌍 **Location, split for you** — `location`, plus best-effort `city` / `state` / `country`, and a boolean `remote` flag.
- 📝 **Full descriptions** — both `descriptionHtml` (original markup) and a clean `descriptionText`, plus a short `snippet` for previews.
- 🔀 **Cross-source de-duplication** — the same job posted on two boards is merged by title + company, so you don't pay for duplicates.
- 🗄️ **Real Indeed archive mode** — historical Indeed postings via the Wayback Machine, with automatic **Cloudflare-challenge-page detection** (empty/challenge captures are skipped, never saved as junk rows).
- 🗂️ **3 pre-built dataset views** — Overview, Live jobs, Indeed archive — slice the data with zero post-processing.
- ⚡ **Keyless & fast** — pure HTTP (no browser, no OAuth). Every item carries `source`, `_mode` and `scrapedAt` (ISO 8601).
#### The 2 engines (modes)
| Mode | What it returns |
|---|---|
| `live` | Aggregated fresh job feed from Arbeitnow + RemoteOK + Jobicy + Himalayas, normalized, de-duped and filtered (highest volume, the default). |
| `indeedArchive` | Real Indeed job postings parsed from public web-archive snapshots (`JobPosting` JSON-LD + Indeed job-cards), Indeed-branded historical data. |
### 👥 Who is it for
- **Recruiters & staffing agencies** building a live pipeline of open roles and hiring companies.
- **Lead-generation teams** who want a fresh list of companies that are hiring (a company that's hiring is a company that's spending).
- **HR & compensation analysts** benchmarking salaries by role, seniority and location.
- **Job-board & aggregator builders** who need a keyless upstream feed to seed or supplement their own listings.
- **Data scientists & researchers** studying the labour market, remote-work trends, skills demand or wage distributions.
### 🎯 Use cases
- **Recruiting pipeline** — pull every open "React developer" or "registered nurse" role and route them to your ATS.
- **Sales prospecting** — a company hiring 20 engineers is scaling; surface it before your competitors do.
- **Salary benchmarking** — aggregate `salaryMin` / `salaryMax` by title and seniority to set competitive bands.
- **Remote-work analytics** — filter `remote:true` and chart the share of remote roles by category over time.
- **Skills-demand tracking** — count how often a technology appears in `tags` / `title` week over week.
- **Market monitoring** — schedule the Actor daily and diff the results to catch new postings the moment they appear.
### 💡 Why use it (vs. fighting Cloudflare yourself)
1. **It actually returns data.** Live Indeed 403s keyless scrapers; this Actor sidesteps that entirely and still gives you rich job rows.
2. **No API keys, no accounts, no cookies.** Nothing to register, rotate or get suspended.
3. **Volume by design.** Real pagination across four sources → hundreds to thousands of rows in one run.
4. **Clean, typed output.** Numbers are numbers, booleans are booleans, dates are ISO 8601 — ready for BI tools and ML.
5. **De-duplicated.** You don't pay twice for the same posting appearing on two boards.
6. **Honest and maintainable.** Public developer APIs + the public web archive don't change their locks weekly the way an anti-bot vendor does.
### 📊 What data can you extract
Every row — regardless of source or mode — is normalized to this unified schema:
| Field | Type | Description |
|---|---|---|
| `jobId` | string | Stable id (source slug / id, or Indeed job key in archive mode). |
| `title` | string | Job title. |
| `company` | string | Hiring company name. |
| `companyLogo` | string \| null | Company logo URL when available. |
| `location` | string \| null | Full location string. |
| `city` | string \| null | Parsed city (best effort). |
| `state` | string \| null | Parsed state / region code (best effort). |
| `country` | string \| null | Parsed country (best effort). |
| `remote` | **boolean** | Whether the role is remote. |
| `salaryMin` | **number** \| null | Lower bound of advertised pay. |
| `salaryMax` | **number** \| null | Upper bound of advertised pay. |
| `salaryCurrency` | string \| null | Currency code (e.g. `USD`). |
| `salaryPeriod` | string \| null | `year` / `month` / `hour` etc. |
| `salaryText` | string \| null | Human-readable pay string. |
| `jobType` | string[] | Employment type(s): full-time, contract, … |
| `tags` | string[] | Skill / topic tags (source-dependent). |
| `categories` | string[] | Industry / category labels. |
| `seniority` | string \| null | Seniority / experience level. |
| `industry` | string \| null | Primary industry. |
| `snippet` | string \| null | Short plain-text preview. |
| `descriptionText` | string \| null | Full description, plain text. |
| `descriptionHtml` | string \| null | Full description, original HTML. |
| `datePosted` | string \| null | ISO 8601 posting date. |
| `applyUrl` | string \| null | Direct application URL. |
| `jobUrl` | string \| null | Canonical posting URL. |
| `source` | string | `arbeitnow` / `remoteok` / `jobicy` / `himalayas` / `indeed-archive`. |
| `_mode` | string | `live` or `indeedArchive`. |
| `scrapedAt` | string | ISO 8601 timestamp of the scrape. |
#### Real output example (`live` mode)
```json
{
"jobId": "1135188",
"title": "Senior Backend Developer (Go)",
"company": "AlixPartners",
"companyLogo": "https://…/logo.png",
"location": "United States",
"city": null,
"state": null,
"country": "United States",
"remote": true,
"salaryMin": 120000,
"salaryMax": 160000,
"salaryCurrency": "USD",
"salaryPeriod": "year",
"salaryText": "$120,000 - $160,000",
"jobType": ["Full-Time"],
"tags": ["golang", "backend", "engineer", "senior"],
"categories": ["Software Development"],
"seniority": "Senior",
"industry": "Software Development",
"snippet": "We are hiring a senior Go engineer to scale our data platform…",
"descriptionText": "We are hiring a senior Go engineer…",
"descriptionHtml": "We are hiring a senior Go engineer…
",
"datePosted": "2026-07-22T08:00:18.000Z",
"applyUrl": "https://remoteok.com/remote-jobs/1135188",
"jobUrl": "https://remoteok.com/remote-jobs/1135188",
"source": "remoteok",
"_mode": "live",
"scrapedAt": "2026-07-23T09:15:04.000Z"
}
````
### 🚀 How to use (3 steps)
1. **Leave everything empty** and click **Start** for the broadest feed (500+ fresh jobs from all live sources) — or add a **keyword** and/or **location** to narrow it.
2. **(Optional) tune the filters** — remote-only, job type, minimum salary, date posted, or restrict to a single `source`. Switch `mode` to `indeedArchive` for real Indeed postings from the web archive.
3. **Run & export** — download as **JSON, CSV, Excel, HTML, RSS or JSON Lines**, or pull results via the Apify API / MCP.
#### Option A — Apify Console (no code)
Open the Actor, fill the input form (or leave it empty), press **Start**, then use the **Export** button on the dataset.
#### Option B — API / CLI
Start a run and read the dataset via the Apify API (see [API usage](#-api-usage) below), or run it from the Apify CLI.
### 📥 Input parameters
Every field is optional. Empty input returns a broad, useful feed.
| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `live` | `live` (aggregate public feeds) or `indeedArchive` (Indeed from web archive). |
| `query` | string | – | Keyword: job title, skill, technology or role. Matched against title, company, tags, description. |
| `location` | string | – | City, region, country, or `remote`. |
| `remote` | boolean | `false` | Keep only remote jobs. |
| `source` | select | `all` | `all` (aggregate + dedupe) or a single board: arbeitnow / remoteok / jobicy / himalayas. |
| `jobType` | select | – | full-time / part-time / contract / temporary / internship. |
| `datePosted` | select | `any` | any / 1 / 3 / 7 / 14 days. |
| `salaryMin` | integer | – | Minimum advertised salary (drops jobs with no salary when set). |
| `maxResults` | integer | `500` | Upper bound; drives how deep each source paginates. |
#### Example — broad fresh feed (empty input)
```json
{}
```
#### Example — remote developer jobs, decent pay
```json
{
"mode": "live",
"query": "developer",
"remote": true,
"salaryMin": 90000,
"maxResults": 600
}
```
#### Example — full-time nursing jobs, aggregated
```json
{
"mode": "live",
"query": "nurse",
"jobType": "fulltime",
"maxResults": 500
}
```
#### Example — real Indeed postings from the web archive
```json
{
"mode": "indeedArchive",
"query": "software developer",
"location": "New York",
"maxResults": 200
}
```
### 📤 Output
Results stream to the Actor's default **dataset**, one row per job, in the unified schema above. Three ready-made **views** are included:
- **Overview** — the common columns across every source and mode.
- **Live jobs** — the full aggregated feed (best for `live`).
- **Indeed archive** — archived Indeed postings (best for `indeedArchive`).
Export any view to **JSON, CSV, Excel, HTML, RSS or JSON Lines** from the Console, or via the API.
### 🧠 Tips for best results
1. **Empty input = maximum volume.** Add filters only to narrow. Start broad, then tighten.
2. **Use `maxResults` to control cost and depth.** Higher values paginate more pages per source.
3. **`source: all` de-duplicates** — same job on two boards is merged. Pick a single source only if you specifically want that board.
4. **Keyword matches broadly** — it checks title, company, tags and description, so `python` surfaces "Python", "Django/Python", etc.
5. **`location` accepts `remote`** — combine with `remote:true` for a strict remote filter.
6. **`salaryMin` drops unpaid-listing rows** — many postings omit salary; set this only when you truly need pay data.
7. **The live sources skew tech / remote** — for warehouse, nursing or retail roles you'll still get hits, but volume is highest for software, marketing, sales and operations.
8. **`indeedArchive` is historical by nature** — snapshots reflect when Indeed pages were captured, not this second. Use it for Indeed-branded data and back-testing.
9. **Schedule it** — run daily and diff datasets to catch brand-new postings.
10. **Watch `datePosted`** — filter to the last 1–7 days for a "what's new" feed.
### 🔌 Integrations
Send results anywhere Apify integrates: **Zapier, Make, n8n, Slack, Google Sheets/Drive, GitHub, Airbyte, webhooks**, or your own backend. Push job rows straight into a CRM, ATS, spreadsheet or data warehouse. Trigger runs on a schedule and pipe new rows to Slack or email.
### 🛠️ API usage
Start a run and fetch the dataset with the Apify API. Replace `` with your Apify token.
**cURL**
```bash
## Start a run
curl -s -X POST "https://api.apify.com/v2/acts/logiover~indeed-jobs-scraper/runs?token=" \
-H "Content-Type: application/json" \
-d '{"query":"developer","remote":true,"maxResults":600}'
## Fetch dataset items (after it finishes)
curl -s "https://api.apify.com/v2/acts/logiover~indeed-jobs-scraper/runs/last/dataset/items?token=&clean=true&format=json"
```
**JavaScript (apify-client)**
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '' });
const run = await client.actor('logiover/indeed-jobs-scraper').call({
query: 'developer',
remote: true,
maxResults: 600,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'jobs');
```
**Python (apify-client)**
```python
from apify_client import ApifyClient
client = ApifyClient("")
run = client.actor("logiover/indeed-jobs-scraper").call(run_input={
"query": "developer",
"remote": True,
"maxResults": 600,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(len(items), "jobs")
```
### 🤖 MCP / AI agents
This Actor is a clean **jobs data tool for AI agents**. Because it's keyless and returns structured JSON, you can wire it into an LLM agent (via the Apify MCP server or a direct API call) to answer questions like *"find remote Python jobs paying over $100k"* or *"list companies hiring data engineers this week"*. Every field is typed, so the model can filter, rank and summarize without scraping HTML itself.
### ❓ FAQ
#### Does this scrape indeed.com live?
No — and neither can any keyless scraper. Indeed's site is behind Cloudflare Turnstile and returns `403` to unauthenticated bots. This Actor instead aggregates **keyless public job-board APIs** (live) and parses **real Indeed postings from the public web archive** (`indeedArchive`). You get Indeed-style job data with **no API key and no blocked requests**.
#### Is there an Indeed job data API without an API key?
Yes — this Actor *is* that, in effect. It exposes a clean, keyless **job-listings API** you call through Apify: send a keyword/location, get back structured jobs. No Indeed key, no OAuth, no login.
#### How do I scrape Indeed jobs into a CSV?
Run the Actor (empty input or with a keyword), then click **Export → CSV** on the dataset, or call the API with `format=csv`. You can **export Indeed-style job data to CSV, Excel or JSON** in one click.
#### Where does the salary data come from?
From the sources that publish it (RemoteOK, Jobicy and Himalayas expose pay ranges; Indeed archive snapshots carry `baseSalary` in JSON-LD). Salary is stored as **real numbers** in `salaryMin` / `salaryMax` with `salaryCurrency` and `salaryPeriod`. Set `salaryMin` to keep only paid listings.
#### How many jobs can I get per run?
Hundreds to thousands. The default `live` mode aggregates four sources with real pagination — an empty run returns **500+**, and `maxResults` can push it into the thousands.
#### Why do I see `source: remoteok` / `jobicy` and not `indeed`?
In `live` mode the data comes from those keyless job boards, tagged honestly with their `source`. Switch to `mode: indeedArchive` to get rows tagged `indeed-archive` sourced from real archived Indeed pages.
#### Does `indeedArchive` always return data?
It returns real Indeed postings **when reachable, non-challenge snapshots exist** for your query. Some archived captures are themselves Cloudflare "Just a moment" pages — the Actor **detects and skips** those rather than saving junk. For guaranteed volume, use the default `live` engine.
#### Can I get only remote jobs?
Yes — set `remote: true` (and/or `location: remote`). The live sources are remote-friendly, so remote volume is high.
#### Can I filter by job title or skill?
Yes — `query` matches against title, company, tags and description, so a skill like `kubernetes` or a role like `product manager` both work.
#### Is the data fresh?
The `live` sources update continuously (hourly on several boards) and are ordered newest-first, so you get current openings. Use `datePosted` to keep only the last N days.
#### Can I run this on a schedule?
Yes — use Apify **Schedules** to run it daily/hourly and pipe new rows to Slack, Sheets, a webhook or your database.
#### What if a source is temporarily down?
Each source is fetched independently with retries; if one is unavailable the others still deliver, so the run still returns data.
### ⚖️ Is it legal?
This Actor uses **public developer APIs** (Arbeitnow, RemoteOK, Jobicy, Himalayas — all of which publish these endpoints for third-party use) and the **public web archive** (archive.org). It does **not** bypass Indeed's authentication or anti-bot systems, and it collects only **publicly available** job-posting information — no personal data beyond what employers publish in a listing, and no login-gated content. You are responsible for complying with each source's terms and with applicable data-protection law (e.g. GDPR) when you store or process the results. When in doubt, consult your legal team.
### 🔗 Related scrapers
Looking for more hiring & company data? Explore the rest of the **logiover** collection on Apify for company registries, lead-generation and business-data Actors that pair well with this jobs scraper.
# Actor input Schema
## `mode` (type: `string`):
Which engine to run.
• **live** — aggregate fresh openings from keyless public job-board APIs (Arbeitnow, RemoteOK, Jobicy, Himalayas), normalized into one schema, de-duplicated and filtered by your query. Guaranteed high volume. (DEFAULT)
• **indeedArchive** — real Indeed job postings pulled from the public web archive (archive.org). Parses JobPosting JSON-LD and Indeed's job-cards data from archived snapshots. Great for Indeed-branded historical data.
## `query` (type: `string`):
Free-text keyword to filter jobs by — job title, skill, technology or role (e.g. `developer`, `nurse`, `python`, `sales`). Matched against title, company, tags and description. Leave empty to return everything.
## `location` (type: `string`):
Free-text location filter — city, region or country (e.g. `New York`, `London`, `Germany`), or `remote` for remote-only. Matched against each job's location. Leave empty for worldwide.
## `remote` (type: `boolean`):
If enabled, keep only jobs that are explicitly remote.
## `source` (type: `string`):
Which live job-board source(s) to pull from in **live** mode. `All` aggregates every source and de-duplicates (highest volume).
## `jobType` (type: `string`):
Keep only jobs of this employment type. Leave empty for all types.
## `datePosted` (type: `string`):
Keep only jobs posted within this many days. `Any time` keeps everything. (Applied to sources that expose a post date.)
## `salaryMin` (type: `integer`):
Keep only jobs whose advertised salary is at or above this number (jobs without a salary are dropped when this is set). Interpreted in the job's own currency.
## `maxResults` (type: `integer`):
Upper bound on the number of jobs returned. Drives how deep each source is paginated. Empty input with a high value returns the broadest feed.
## Actor input object example
```json
{
"mode": "live",
"query": "developer",
"location": "remote",
"remote": false,
"source": "all",
"datePosted": "any",
"maxResults": 500
}
```
# Actor output Schema
## `results` (type: `string`):
Full results dataset. Use the Live jobs view for the aggregated feed and the Indeed archive view for archived Indeed postings.
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "live",
"query": "developer",
"source": "all",
"maxResults": 500
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/indeed-jobs-scraper").call(input);
// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.dir(item);
});
// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs
```
## Python example
```python
from apify_client import ApifyClient
# Initialize the ApifyClient with your Apify API token
# Replace '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "live",
"query": "developer",
"source": "all",
"maxResults": 500,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/indeed-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 '{
"mode": "live",
"query": "developer",
"source": "all",
"maxResults": 500
}' |
apify call logiover/indeed-jobs-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/indeed-jobs-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Indeed Jobs Scraper — Job Listings & Salary Data API (No Key)",
"description": "Keyless job-listings API in the spirit of Indeed — no login, no Cloudflare walls. Aggregates thousands of fresh openings from public job-board APIs plus real Indeed postings from the public web archive. Filter by keyword, location, remote, type and salary. Export to JSON, CSV or Excel.",
"version": "1.0",
"x-build-id": "9LlwxWbaqXxxS5rfH"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~indeed-jobs-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-indeed-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/logiover~indeed-jobs-scraper/runs": {
"post": {
"operationId": "runs-sync-logiover-indeed-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/logiover~indeed-jobs-scraper/run-sync": {
"post": {
"operationId": "run-sync-logiover-indeed-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": {
"mode": {
"title": "Mode",
"enum": [
"live",
"indeedArchive"
],
"type": "string",
"description": "Which engine to run.\n\n• **live** — aggregate fresh openings from keyless public job-board APIs (Arbeitnow, RemoteOK, Jobicy, Himalayas), normalized into one schema, de-duplicated and filtered by your query. Guaranteed high volume. (DEFAULT)\n• **indeedArchive** — real Indeed job postings pulled from the public web archive (archive.org). Parses JobPosting JSON-LD and Indeed's job-cards data from archived snapshots. Great for Indeed-branded historical data.",
"default": "live"
},
"query": {
"title": "Search keyword",
"type": "string",
"description": "Free-text keyword to filter jobs by — job title, skill, technology or role (e.g. `developer`, `nurse`, `python`, `sales`). Matched against title, company, tags and description. Leave empty to return everything."
},
"location": {
"title": "Location",
"type": "string",
"description": "Free-text location filter — city, region or country (e.g. `New York`, `London`, `Germany`), or `remote` for remote-only. Matched against each job's location. Leave empty for worldwide."
},
"remote": {
"title": "Remote only",
"type": "boolean",
"description": "If enabled, keep only jobs that are explicitly remote.",
"default": false
},
"source": {
"title": "Source (live mode)",
"enum": [
"all",
"arbeitnow",
"remoteok",
"jobicy",
"himalayas"
],
"type": "string",
"description": "Which live job-board source(s) to pull from in **live** mode. `All` aggregates every source and de-duplicates (highest volume).",
"default": "all"
},
"jobType": {
"title": "Job type",
"enum": [
"fulltime",
"parttime",
"contract",
"temporary",
"internship"
],
"type": "string",
"description": "Keep only jobs of this employment type. Leave empty for all types."
},
"datePosted": {
"title": "Date posted",
"enum": [
"any",
"1",
"3",
"7",
"14"
],
"type": "string",
"description": "Keep only jobs posted within this many days. `Any time` keeps everything. (Applied to sources that expose a post date.)",
"default": "any"
},
"salaryMin": {
"title": "Minimum salary",
"minimum": 0,
"type": "integer",
"description": "Keep only jobs whose advertised salary is at or above this number (jobs without a salary are dropped when this is set). Interpreted in the job's own currency."
},
"maxResults": {
"title": "Max results",
"minimum": 1,
"maximum": 5000,
"type": "integer",
"description": "Upper bound on the number of jobs returned. Drives how deep each source is paginated. Empty input with a high value returns the broadest feed.",
"default": 500
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```