# Jooble Scraper \[Only $0.001💰] | Jobs | Salary | Apply URL (`ahmed_jasarevic/jooble-scraper`) Actor

Scrape Jooble job listings from 70+ countries: job title, company, location, salary, full description, and apply URL. Build job databases, run market research, and track hiring trends. No API key needed.

- **URL**: https://apify.com/ahmed\_jasarevic/jooble-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Jooble Scraper

Extract **Jooble job listings from 70+ country subdomains** (jooble.org for the US, uk.jooble.org, de.jooble.org, in.jooble.org, au.jooble.org and more) with job title, company, location, salary, posting date, full description and apply URL for every result — no Jooble API key required.

Built for recruiters, staffing agencies, job-board operators and workforce-intelligence teams who need structured, up-to-date job market data for hiring research, salary benchmarking and lead generation.

### Main Use Cases

- **Job market research** — collect real job postings across countries to analyze demand, skills and salaries by market.
- **Salary benchmarking** — extract salary ranges from listings to benchmark compensation for roles, regions and industries.
- **Hiring trends tracking** — monitor hiring volume, new postings and top employers over time for competitor analysis.
- **Job board database building** — feed a niche job aggregator, career portal or internal ATS with fresh structured listings.
- **Recruitment automation** — automate sourcing of job adverts for staffing agencies and talent-sourcing pipelines.
- **Remote and international job data** — search `Remote` and regional subdomains to cover global hiring markets.

### How It Works

Enter job keywords (e.g. `software engineer`) and optional locations, pick a Jooble country subdomain, and start the run. The actor searches Jooble's result pages, extracts one structured record per job listing (with full description when enabled), and stores everything in an Apify dataset you can download as JSON, CSV, HTML or Excel.

### Extract Jooble Job Listings for Market Research

Jooble aggregates vacancies from thousands of career sites and job boards per country. The actor turns those aggregator pages into clean, queryable data: each dataset row contains the job title, hiring company, location, salary range, snippet, full description text, employment type, posting date and the direct apply URL — filtered by keyword and location exactly like a Jooble search.

### Build Job Databases Without an Official Jooble API Key

The official Jooble REST API is free but restrictive: each API key has a **lifetime limit of 500 requests**, every country subdomain needs its **own key**, and responses return only truncated description **snippets** — not full records. This actor has no key requirement, covers 70+ country subdomains, and optionally fetches the **full description** from each job's detail page, giving you a complete record for database and analysis use cases.

### Input

All fields are optional unless noted. Defaults come from the actor's input schema.

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `searchQueries` | array | No | `["software engineer"]` | Job keywords/titles to search for, e.g. `["data scientist"]`. |
| `locations` | array | No | `[]` | City/region to search in, e.g. `["New York"]`. Empty = whole country. |
| `searchUrls` | array | No | `[]` | Paste exact Jooble search URLs to override keyword building, e.g. `https://jooble.org/jobs?ukw=data+engineer&rgns=London`. |
| `country` | string | No | `jooble.org` | Jooble country subdomain: `jooble.org` (US), `uk.jooble.org`, `de.jooble.org`, `in.jooble.org`, `au.jooble.org`... |
| `maxItems` | integer | No | `100` | Maximum number of jobs to scrape (`1–10000`). Free plans are capped at 10 per run. |
| `maxPagesPerSearch` | integer | No | `3` | How many result pages (20 jobs each) to walk per keyword. |
| `fetchFullDescriptions` | boolean | No | `true` | Follow each job's detail page to extract the full description. Set `false` for faster snippet-only runs. |

### Output

Each dataset item is one job listing with these fields:

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title |
| `company` | string | Hiring company name |
| `location` | string | Job location (city, region, country) |
| `salary` | string | Salary range when Jooble provides it |
| `snippet` | string | Description snippet from the search result page |
| `description` | string | Full description text (when `fetchFullDescriptions` is enabled) |
| `source` | string | Original job-board/career-site source of the vacancy |
| `jobType` | string | Employment type (Full-time, Part-time, ...) |
| `applyUrl` | string | Direct URL to the job listing on Jooble |
| `postedDate` | string | Posting date (ISO date) |
| `country` | string | Country name of the listing |
| `url` | string | Canonical job URL |
| `scrapedAt` | string | ISO timestamp of when the row was scraped |

### Example Input

```json
{
  "searchQueries": ["software engineer", "data scientist"],
  "locations": ["New York", "Remote"],
  "country": "jooble.org",
  "maxItems": 100,
  "maxPagesPerSearch": 3,
  "fetchFullDescriptions": true
}
```

### Example Output

```json
{
  "title": "Full Stack Software Engineer",
  "company": "LM Studio",
  "location": "Remote",
  "salary": "$164k - $229k",
  "snippet": "...join us and build the future of human-AI interactions...",
  "description": "...full job description text...",
  "source": "grabjobs.co",
  "jobType": "Full-time",
  "applyUrl": "https://jooble.org/desc/3758529980229519458?ckey=software+engineer",
  "postedDate": "2026-09-08T00:00:00",
  "country": "United States",
  "url": "https://jooble.org/desc/3758529980229519458",
  "scrapedAt": "2026-09-08T16:24:46.649Z"
}
```

### Track Hiring Trends Automatically

Set up a recurring schedule (daily or weekly) on the actor's **Schedules** tab to keep a rolling dataset of job postings per market. Monitor new vacancies, salary movements and hiring spikes over time, and push results to your warehouse via webhooks, Zapier or Make. Recurring runs also improve the actor's Apify Store recommendation signals, keeping the tool fresh for your use case.

### Related Actors

- [LinkedIn Jobs Scraper](https://apify.com/curious_coder/linkedin-jobs-scraper) — job listings from LinkedIn search results
- [Indeed Jobs Scraper](https://apify.com/borderline/indeed-scraper) — pay-per-result Indeed job extraction
- [Career Site Job Listing API](https://apify.com/fantastic-jobs/career-site-job-listing-api) — direct postings from 175k+ company career sites and ATS platforms
- [Jooble Jobs Scraper (agentx)](https://apify.com/agentx/jooble-jobs-scraper) — Jooble API alternative with 41 structured fields
- [StepStone Job Scraper](https://apify.com/memo23/stepstone-search-cheerio-ppr) — job listings from StepStone in Germany, Austria & Belgium

### FAQ

#### Why use this actor instead of the official Jooble API?

The free Jooble REST API has a **500-request lifetime limit per key** — once exhausted, the key stops working forever. It also requires a separate key per country subdomain, and only returns truncated description snippets. This actor needs **no API key**, covers **70+ country subdomains**, and can return **full job descriptions**, making it viable for database building and analysis workloads the official API can't handle.

#### What are alternatives to Jooble for international job data?

Other aggregators of global job listings include **Indeed**, **Adzuna**, **Talent.com** and ATS-based feeds such as **JobsPipe** (Workday, Greenhouse, Lever, Ashby). Within the Apify ecosystem, comparable actors are the [LinkedIn Jobs Scraper](https://apify.com/curious_coder/linkedin-jobs-scraper), [Indeed Jobs Scraper](https://apify.com/borderline/indeed-scraper) and the [Career Site Job Listing API](https://apify.com/fantastic-jobs/career-site-job-listing-api).

#### Can I scrape Jooble without an API key?

Yes — that is the default. After starting the run, set your job keywords and location (or paste search URLs directly), and the actor handles Jooble's Cloudflare protection automatically with a layered HTTP + stealth-browser (Camoufox) strategy.

#### Can I scrape multiple countries in one run?

Each run targets one Jooble country subdomain, but you can run multiple searches by passing several keywords, locations or direct search URLs in a single run — or run the actor several times with different `country` values and merge the datasets.

#### Is scraping Jooble legal?

Scraping publicly available job listings for research and analysis is generally acceptable, but you should review Jooble's Terms of Service and applicable laws in your jurisdiction before running at scale. This actor only accesses publicly available pages, respects rate limits, and does not bypass account/login restrictions.

#### How much does Jooble Scraper cost?

The actor uses pay-per-event pricing: a small Actor-start event plus a per-result price for each job listing delivered. Free Apify plans get a capped preview of 10 items per run. See the pricing tab on the actor page for the exact per-result price for your tier.

### SEO Keywords

jooble scraper, jooble job listings, scrape jooble jobs, jooble jobs api, jooble api alternative, jooble api without key, job listings scraper, job board scraper, job search api, job postings database, job market analysis, hiring trends data, labor market intelligence, recruitment data, salary data scraping, salary benchmarking, remote jobs scraper, uk job listings, germany job listings, india job listings, us job listings, jooble data extraction, job aggregator data, workforce analytics

### For AI Agents & LLM Apps

**Purpose:** Returns structured job listings (title, company, location, salary, description, apply URL) from Jooble search results, callable via the Apify API or MCP.

**Minimal input:**

```json
{
  "searchQueries": ["software engineer"],
  "country": "jooble.org"
}
```

**Fast snippet-only variant:**

```json
{
  "searchQueries": ["data scientist"],
  "locations": ["Berlin"],
  "country": "de.jooble.org",
  "fetchFullDescriptions": false,
  "maxPagesPerSearch": 1
}
```

**Output fields:** `title`, `company`, `location`, `salary`, `snippet`, `description`, `source`, `jobType`, `applyUrl`, `postedDate`, `country`, `url`, `scrapedAt`.

**Behaviors an agent should know:**

- All inputs are optional; the actor defaults to `["software engineer"]` on `jooble.org` with `maxItems: 100` and `fetchFullDescriptions: true`.
- `searchUrls` take priority over `searchQueries` for building searches — if you pass direct URLs, keywords are ignored for those URLs.
- Free-plan users are capped at 10 items per run regardless of `maxItems`.
- Setting `fetchFullDescriptions: true` (default) follows every detail page — richer output but slower and more expensive per run; set `false` for cheap, fast, snippet-only extraction.
- `maxPagesPerSearch` × 20 jobs per page bounds the search depth per keyword; `maxItems` is the hard cap across all searches.
- Returns only publicly available Jooble listing data — no login-based or private content.

**Billing model:** pay-per-event — one Actor-start event plus one per-result event per job listing delivered.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Jooble** (JOOBLE Inc.). It accesses only publicly available Jooble search and job-detail pages — it does not bypass login walls, solve CAPTCHAs or access non-public data. Users are responsible for reviewing Jooble's Terms of Service and applicable data-protection law in their jurisdiction before scraping at scale. The dataset may contain salary and contact-free listing information published publicly by employers; do not use it in ways that violate the source platform's terms or applicable law.

# Actor input Schema

## `searchQueries` (type: `array`):

Job keywords/titles to search for, e.g. \["software engineer", "data scientist"]. Defaults to \["software engineer"].

## `locations` (type: `array`):

City/region to search in, e.g. \["New York"]. Leave empty to search the whole country.

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

Optional: paste exact Jooble search URLs instead of building them from keywords, e.g. https://jooble.org/jobs?ukw=data+engineer\&rgns=London

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

Jooble country subdomain. Default jooble.org (US). Examples: uk.jooble.org, de.jooble.org, in.jooble.org, au.jooble.org.

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

Maximum number of jobs to scrape. Free users are capped at 10.

## `maxPagesPerSearch` (type: `integer`):

How many result pages (20 jobs each) to walk per keyword.

## `fetchFullDescriptions` (type: `boolean`):

Follow each job's detail page to extract the full description. Slower but richer output.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "locations": [],
  "searchUrls": [],
  "country": "jooble.org",
  "maxItems": 100,
  "maxPagesPerSearch": 3,
  "fetchFullDescriptions": true
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "software engineer"
    ],
    "locations": [],
    "searchUrls": [],
    "country": "jooble.org"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/jooble-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 = {
    "searchQueries": ["software engineer"],
    "locations": [],
    "searchUrls": [],
    "country": "jooble.org",
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/jooble-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 '{
  "searchQueries": [
    "software engineer"
  ],
  "locations": [],
  "searchUrls": [],
  "country": "jooble.org"
}' |
apify call ahmed_jasarevic/jooble-scraper --silent --output-dataset

```

## MCP server setup

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