# Jooble API: Key, Endpoint, Limits and Examples

> How the Jooble REST API works: requesting a key, the POST endpoint, every request and response field, the 500-request limit, and curl, JS and Python code.

Source: https://cleanjobdata.com/articles/jooble-api-guide
Published: 2026-11-01

TL;DR: Jooble's REST API is a single search call: POST https://jooble.org/api/{your_key} with a JSON body where keywords and location are required. You get a key by filling in the form at jooble.org/api/about, and each country domain needs its own key. Jooble's help center says the free plan has a lifetime limit of 500 requests per key, not a monthly quota, and no paid pricing is published. Responses carry a totalCount and a jobs array with title, location, a short snippet, a salary string, source, type, link, company and updated.

The Jooble API is one search endpoint: send `POST https://jooble.org/api/{your_key}` with a JSON body containing `keywords` and `location`, and you get back matching jobs as JSON. You request the key through a form on [jooble.org/api/about](https://jooble.org/api/about), and Jooble's help center says the free plan allows 500 requests per key in total, a lifetime cap rather than a monthly one.

Jooble is a job search engine that aggregates listings from many job sites, and the API was built for website owners who want to show Jooble search results on their own pages. This guide covers getting a key, the full request and response, working code, and the limits that matter before you build on it. Everything here was checked against Jooble's own pages on November 1, 2026.

## At a Glance

| | |
|---|---|
| Endpoint | `POST https://jooble.org/api/{your_key}` |
| Auth | Key in the URL path, no header |
| Required fields | `keywords`, `location` |
| Free plan | 500 requests per key, lifetime (per Jooble's help center) |
| Paid plans | No published pricing |
| Keys | One per country domain (jooble.org, uk.jooble.org, de.jooble.org, …) |
| Description | Short `snippet` only, not the full posting |
| Salary | One formatted string, not min/max fields |

## How to Get a Jooble API Key

Go to [jooble.org/api/about](https://jooble.org/api/about) and fill in the request form: your name, position, email, website and phone number. The page describes the API as being for "webmasters of an internet portal or search engine" who want to post Jooble's results on their site in their own design, so expect the website field to matter.

Keys are tied to a country. A key from jooble.org covers US listings only; for the UK, Germany or any other market you register again on that country's domain, such as uk.jooble.org or de.jooble.org. If your product spans several countries, plan for several keys and one request per country.

## The Endpoint

There's one call. The key goes in the URL, the search goes in a JSON body, and the method is POST even though it's a read:

```bash
curl -X POST "https://jooble.org/api/YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"keywords": "backend developer", "location": "Austin"}'
```

## Request Fields

| Field | Type | Required | Notes |
|---|---|---|---|
| `keywords` | string | Yes | Keywords or job title |
| `location` | string | Yes | City, region or country |
| `radius` | string | No | Kilometers; allowed values are 0, 4, 8, 16, 26, 40 and 80 |
| `salary` | integer | No | Minimum salary |
| `page` | integer | No | Results page, defaults to 1 |
| `ResultOnPage` | integer | No | Jobs per page; no default is documented |
| `SearchMode` | integer | No | Search algorithm mode, defaults to 0 |
| `companysearch` | boolean | No | `true` searches company names; `false` searches titles and descriptions |

Note the mixed casing: `ResultOnPage` and `SearchMode` are PascalCase while everything else is lowercase. Jooble's own example request sends `radius`, `page` and `companysearch` as strings even though the table lists other types, so the API appears to accept either.

## The Response

A successful call returns `totalCount` and a `jobs` array. The fields below are the ones Jooble documents; the values are illustrative:

```json
{
  "totalCount": 412,
  "jobs": [
    {
      "id": 4567891234,
      "title": "Backend Developer",
      "location": "Austin, TX",
      "snippet": "...We are looking for a backend developer to build and scale our payments APIs...",
      "salary": "120000 - 150000 USD",
      "source": "example-jobboard.com",
      "type": "Full-time",
      "link": "https://jooble.org/...",
      "company": "Acme Inc",
      "updated": "2026-10-30T09:15:00"
    }
  ]
}
```

| Field | What it is |
|---|---|
| `totalCount` | Total jobs matching the search |
| `id` | Jooble's job ID (an integer) |
| `title` | Job title |
| `location` | Location as one display string |
| `snippet` | A short excerpt of the description, not the full text |
| `salary` | One formatted string, `{min} - {max} {currency}`, often empty |
| `source` | The site Jooble found the job on |
| `type` | Employment type, such as Full-time or Part-time |
| `link` | Jooble's URL for the job |
| `company` | Company name |
| `updated` | Timestamp of the last update |

## Code Examples

### JavaScript (Node 18+)

```javascript
const JOOBLE_KEY = process.env.JOOBLE_API_KEY;

async function searchJooble({ keywords, location, page = 1 }) {
  const res = await fetch(`https://jooble.org/api/${JOOBLE_KEY}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ keywords, location, page }),
  });

  if (res.status === 403) throw new Error("Jooble rejected the key (invalid or missing)");
  if (!res.ok) throw new Error(`Jooble API error: ${res.status}`);

  const { totalCount, jobs } = await res.json();
  return { totalCount, jobs };
}

const { totalCount, jobs } = await searchJooble({ keywords: "data engineer", location: "Chicago" });
console.log(`${totalCount} matches, ${jobs.length} on this page`);
```

### Python

```python
import os
import requests

JOOBLE_KEY = os.environ["JOOBLE_API_KEY"]

def search_jooble(keywords: str, location: str, page: int = 1) -> dict:
    res = requests.post(
        f"https://jooble.org/api/{JOOBLE_KEY}",
        json={"keywords": keywords, "location": location, "page": page},
        timeout=30,
    )
    if res.status_code == 403:
        raise RuntimeError("Jooble rejected the key (invalid or missing)")
    res.raise_for_status()
    return res.json()

data = search_jooble("data engineer", "Chicago")
print(data["totalCount"], "matches")
for job in data["jobs"]:
    print(job["title"], "|", job["company"], "|", job["location"])
```

## Paging Through Results

Pagination is `page` plus, optionally, `ResultOnPage`. Request page 1, compare how many jobs you've collected against `totalCount`, and keep incrementing `page` until you have them all or a page comes back empty.

Every page is a request, and on the free plan every request counts against a lifetime total of 500. A search with a few hundred matches can cost dozens of requests to walk completely, so cache results and only page as deep as your product needs.

## Errors

Jooble documents three status codes:

| Status | Meaning |
|---|---|
| 200 | Success |
| 403 | Access denied: the key is invalid or missing |
| 404 | The endpoint or resource doesn't exist |

If a key returns 403, also check you're using it on the country domain it was issued for: each key covers one Jooble market.

## Limits and Pricing

Jooble's help center states that the free plan includes "a total lifetime limit of 500 requests per key" and stresses that it's an absolute lifetime quota, not a monthly limit. We couldn't find a published paid plan, price list or rate-limit table, so anything beyond the free plan is something to arrange with Jooble directly.

In practice this makes the API a fit for low-volume uses such as a search widget with caching. It's not a fit for syncing a large job database, where 500 requests run out quickly.

## What the Jooble API Doesn't Give You

- **Full descriptions.** You get a `snippet`; the full posting is behind `link`, on Jooble.
- **Structured salary.** `salary` is one string such as `120000 - 150000 USD`, and often empty, so you parse it yourself.
- **Structured location.** `location` is display text with no city, state or country IDs and no coordinates.
- **Direct employer apply links.** `link` sends users to the job through Jooble rather than straight to the employer's own posting.
- **Company data.** Only a company name: no logo, website or size.

## Alternatives

If you need full descriptions, structured fields or more volume, these are the usual next steps:

- [CleanJobData vs Jooble](https://cleanjobdata.com/vs/jooble-api): a side-by-side with an API that sources jobs directly from employer ATS platforms and career sites, with a self-serve key and published pricing.
- [Adzuna's free job API](https://cleanjobdata.com/articles/how-to-integrate-adzuna-free-job-api): another aggregator API, with published default limits.
- [The best free job APIs in 2026](https://cleanjobdata.com/articles/best-free-job-apis-2026): every free option we've tested, including ones that need no key.

## FAQ

### Is the Jooble API free?

Yes, the key is free, but Jooble's help center limits the free plan to 500 requests per key in total, for the life of the key. No paid pricing is published.

### How do I get a Jooble API key?

Fill in the form at jooble.org/api/about with your name, position, email, website and phone number. Each country domain needs its own key, so register on uk.jooble.org, de.jooble.org and so on for other markets.

### Where is the Jooble API documentation?

In the Jooble Help Center, in the "REST API documentation" article. It documents one endpoint, `POST https://jooble.org/api/{api_key}`, the request fields and the response fields listed above.

### What are the Jooble API rate limits?

The only documented limit is the 500-request lifetime cap per key on the free plan. Jooble doesn't publish a per-second or per-minute rate limit.

### Is there a Jooble API alternative without an approval step?

CleanJobData is self-serve: sign up and get a key immediately, then search with GET requests and a Bearer token. Its listings come from employer ATS platforms and career sites rather than Jooble's index, so it isn't a copy of Jooble's results. See the [Jobs API reference](https://cleanjobdata.com/docs/api/jobs) or try it in the [playground](https://cleanjobdata.com/playground).