# Jooble Jobs Search Scraper (`jobsapi/jooble-jobs-search-scraper`) Actor

Scrape job listings from Jooble, a global job search aggregator operating in 70+ countries. Extract job titles, companies, locations, salary ranges, and descriptions for international recruitment and cross-border job market analysis.

- **URL**: https://apify.com/jobsapi/jooble-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 1 total users, 1 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 job details

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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### What does Jooble Jobs Search Scraper do?

This Apify Actor extracts complete, publicly available job postings from [Jooble](https://jooble.org). It uses native HTTPS and Cheerio, with optional Apify Proxy support for public HTML and an optional user-supplied first-party Jooble API key. A record is written only after its Jooble URL, identity, employer, location, and public description have been verified.

### Why use Jooble Jobs Search Scraper?

- Search public Jooble country sites with bounded pages and concurrency.
- Collect complete detail-page text or official API records with explicit verification flags.
- Deduplicate jobs across multiple queries and direct URLs.
- Schedule runs, call the Actor API, export datasets, and use Apify integrations.
- Keep proxy and API-key use optional, visible, and isolated from dataset output.

### How to scrape Jooble jobs

1. Open the input tab and select a mode.
2. Enter a query, country code, and optional location.
3. Start with low `maxItems` and `maxPages` values.
4. Optionally add your Jooble API key or enable Apify Proxy for public HTML.
5. Run the Actor and inspect the dataset and structured run diagnostics.
6. Download results or connect them through the Apify API and integrations.

#### Modes

- `search`: search one query, then enrich bounded result candidates from their public Jooble detail pages.
- `searchMultiple`: run up to five queries and deduplicate the verified records.
- `single`: fetch one official Jooble detail URL.
- `multiple`: fetch up to ten official Jooble detail URLs.
- `startUrls`: accept a bounded mixture of official search and detail URLs.

Jooble’s optional first-party REST API can be used by supplying `apiKey`. API rows are marked as API-verified and are not described as detail-page verified. No API key is included in the reproducible local input.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search`, `searchMultiple`, `single`, `multiple`, or `startUrls`. |
| `query` | string | `developer` | Search phrase for `search`. |
| `queries` | string\[] | `[query]` | Up to five phrases for `searchMultiple`. |
| `location` | string | — | City, state, or region. |
| `country` | string | `us` | Two-letter Jooble country code used for generated searches. |
| `apiKey` | string | — | Optional Jooble-issued API key for the official REST endpoint. |
| `url` | string | — | Official detail URL for `single`. |
| `urls` | object\[] | — | Objects containing official detail URLs for `multiple`. |
| `searchUrls` | string\[] | — | Official search URLs for bounded `search` runs. |
| `startUrls` | object\[] | — | Objects containing official search or detail URLs for `startUrls`. |
| `maxItems` | integer | `3` | Maximum records per query/direct mode; 1–10. |
| `maxPages` | integer | `2` | Maximum search pages/API pages; 1–3. |
| `concurrency` | integer | `4` | Maximum concurrent detail requests; 1–5. |
| `requestTimeoutSecs` | integer | `25` | Per-request timeout; 5–45 seconds. |

Example:

```json
{
  "mode": "search",
  "query": "developer",
  "location": "New York",
  "country": "us",
  "maxItems": 3,
  "maxPages": 2,
  "concurrency": 4,
  "requestTimeoutSecs": 25
}
```

### What data can Jooble Jobs Search Scraper extract?

| Field | Type | Description |
| --- | --- | --- |
| `jobId` | string | Stable Jooble job identifier |
| `jobTitle` | string | Public job title |
| `employer` | string | Hiring organization |
| `location` | string | Published location |
| `description` | string | Complete detail text or official API description |
| `salary` | string | Published salary when available |
| `datePosted` | string | Normalized posting date |
| `publicUrl` | string | Canonical Jooble URL |
| `applicationUrl` | string | Explicit application link when published |

### How much will it cost to scrape Jooble?

The Actor uses lightweight HTTP requests, so compute usage is normally modest. Cost depends on run duration, memory, result limits, and optional proxy traffic. Start with one page and a few jobs to estimate account-specific cost. Proxy use is disabled by default.

### Output and run state

Job rows contain stable IDs, canonical/public URLs, title, employer, location, salary fields, employment type, categories/tags, dates, readable description and HTML, description sections, responsibilities/qualifications/benefits when present, explicit application links only, search provenance, verification receipts, retrieval metadata, and quality counts.

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. `RUN_SUMMARY`, `RUN_DIAGNOSTICS`, `RUN_SKIPS`, and `RUN_HEALTH` are stored in the default key-value store. Anti-bot or access-denied responses fail closed: they produce no fabricated job rows and retain the target status, redacted URL, HTTP status, and stage in diagnostics.

API keys are treated as secrets, are never written to datasets or diagnostics, and are sent only to the official Jooble API. Proxy routing applies only to public HTML requests.

### Local verification

From this directory:

```powershell
npm install --ignore-scripts --no-audit --no-fund
npm test
npm run lint
npx --yes apify-cli validate-schema .actor\input_schema.json
npx --yes apify-cli run --purge --input-file INPUT.json
npm run validate
```

The checked-in `INPUT.json` is the reproducible primary search input. Storage is written below `storage/` and is intentionally local.

### FAQ, disclaimer, and support

#### Why is a run BLOCKED?

Jooble may return HTTP 403 or an access-verification page. Review `RUN_DIAGNOSTICS`, then consider a small proxy-enabled run or the official Jooble API.

#### Does the Actor collect private candidate data?

No. It collects public job advertisements only and does not access authenticated candidate or employer systems.

Our Actors are ethical and do not extract private user data. Results can still contain personal data published in a job advertisement. Personal data is protected by the GDPR and other regulations. Do not process personal data without a legitimate reason; consult your lawyers if unsure. Use the API tab for programmatic access and the Issues tab for support.

### Responsible use

Collect only public job information, respect Jooble’s terms and robots directives, and follow applicable privacy and data-protection requirements. Do not use the Actor for authenticated pages, paywall circumvention, or candidate personal-data harvesting.

# Actor input Schema

## `mode` (type: `string`):

search, searchMultiple, single, multiple, or startUrls.

## `query` (type: `string`):

Keyword or job title for search mode.

## `queries` (type: `array`):

Queries for searchMultiple mode; each query is bounded to maxItems records.

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

Optional city, state, or region passed to Jooble search.

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

Two-letter Jooble country subdomain used for generated search routes.

## `apiKey` (type: `string`):

Optional Jooble-issued API key for its official REST API. Never required for website mode.

## `url` (type: `string`):

Official public Jooble detail or away URL for single mode.

## `urls` (type: `array`):

Official public Jooble detail or away URLs for multiple mode.

## `searchUrls` (type: `array`):

Optional official Jooble search URLs used by search mode.

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

Official Jooble search or detail URLs for startUrls mode.

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

Maximum records per search query or direct-input mode.

## `maxPages` (type: `integer`):

Bounded result pages per query.

## `concurrency` (type: `integer`):

Concurrent official detail requests.

## `requestTimeoutSecs` (type: `integer`):

Maximum time for one official request.

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

Optional Apify Proxy settings for public Jooble HTML. Official API requests remain direct.

## Actor input object example

```json
{
  "mode": "search",
  "query": "developer",
  "country": "us",
  "maxItems": 3,
  "maxPages": 2,
  "concurrency": 4,
  "requestTimeoutSecs": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runSummary` (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 = {
    "query": "developer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/jooble-jobs-search-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 = { "query": "developer" }

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/jooble-jobs-search-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "developer"
}' |
apify call jobsapi/jooble-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jobsapi/jooble-jobs-search-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2CZnc1Y4YMcB6RWMc/builds/FTtV8b7tTmBSjvOT3/openapi.json