# Job Postings RSS Feed API (version 1.6.2)

OpenAPI: https://api.techmap.io/techmap-rss_v1_openapi.json - Postman: https://api.techmap.io/techmap-rss_v1.postman_collection.json

## Introduction

This API provides access to full job postings in long **RSS format**, sourced through web crawling and scraping from various platforms, with jobs available for up to three months.

Job postings are collected directly from a diverse range of sources, including:

-	Techmap’s Web Crawlers
-	ATS Career Pages (e.g., Workday, Personio, JazzHR)
-	Job Boards (e.g., LinkedIn, Monster, Dice)
-	Job Aggregators (e.g., Indeed, Glassdoor, Xing)
-	Government Employment Offices (e.g., German Arbeitsagentur)

This API enables seamless integration of job postings from multiple sources into your job board, career site, or recruitment platform, making it ideal for backfilling job listings with fresh, relevant data.


### Boolean Queries

Most query parameters in the API support flexible Boolean queries, enabling precise filtering of job postings using multiple keywords, keyphrases, and logical operators.
Below are the supported query types:

- **Should Searches (OR):**
  Keywords separated by a comma will match at least one keyword.
  Example: `title=java,developer`
  Matches jobs with either "java" or "developer" in the title.

- **Must Searches (AND):**
  Keywords with an encoded `+` sign (`%2B` in the URL) must be present.
  Example: `title=%2bjava,%2bdeveloper`
  Matches jobs with both "java" and "developer" in the title.

- **Must-Not Searches (NOT):**
  Keywords with a `-` sign before are excluded.
  Example: `title=%2bjava,-mysql`
  Matches jobs with "java" but not "mysql" in the title.

- **Keyphrase Searches:**
  Words separated with spaces in double quotes count as one keyword / keyphrase.
  Example: `city="New York"`
  Matches jobs in "New York".


### Notes
- **Parameter Combinations**: You can combine most parameters, but some combinations may not work together. For example, a geo bounding box cannot be used together with a geo distance search.
- **Field Availability**: Not all fields are populated for every job posting. Commonly missing fields include `state`, `postCode`, or `department`.
- **Authentication**: The key goes into the URL as query parameter `rapidapi-key` - no header needed, so the feed URL works in any job board importer. See *How to authenticate* below.


### Examples

- **Jobs in Germany:**
  ```curl
  curl -X GET "https://job-postings-rss-feed.p.rapidapi.com/api/rss/v1/jobs_full?countryCode=de&rapidapi-key=YOUR_API_KEY"
  ```

## Quickstart (RapidAPI)

1. **Subscribe to the Basic plan** of the [Job Postings RSS Feed API on RapidAPI](https://rapidapi.com/techmap-io-techmap-io-default/api/job-postings-rss-feed/pricing). It has no hard monthly limit - requests above the included quota are billed as overage (see [Errors & billing](https://api.techmap.io/errors-and-billing)).
2. **Copy your key** from the [RapidAPI listing](https://rapidapi.com/techmap-io-techmap-io-default/api/job-postings-rss-feed) → *Endpoints* tab → code snippet → value of `X-RapidAPI-Key` - one key per RapidAPI application.
3. **Make your first call.** Replace `YOUR_API_KEY` in the URL with your key. A successful call returns HTTP **200**.

### curl

```bash
curl --request GET \
  --url 'https://job-postings-rss-feed.p.rapidapi.com/api/rss/v1/jobs_full?countryCode=us&title=developer&rapidapi-key=YOUR_API_KEY'
```

### Python

```python
import requests

url = "https://job-postings-rss-feed.p.rapidapi.com/api/rss/v1/jobs_full"
params = {"countryCode": "us", "title": "developer", "rapidapi-key": "YOUR_API_KEY"}

response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
print(response.text)  # RSS/XML feed
```

### JavaScript

```javascript
// Node.js 18+ or browser
const url = new URL('https://job-postings-rss-feed.p.rapidapi.com/api/rss/v1/jobs_full');
url.search = new URLSearchParams({ 'countryCode': 'us', 'title': 'developer', 'rapidapi-key': 'YOUR_API_KEY' });

const response = await fetch(url);
if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);
console.log(await response.text()); // RSS/XML feed
```

### Java

```java
// Java 11+
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class TechmapExample {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://job-postings-rss-feed.p.rapidapi.com/api/rss/v1/jobs_full?countryCode=us&title=developer&rapidapi-key=YOUR_API_KEY"))
            .GET()
            .build();
        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() != 200) throw new RuntimeException(response.statusCode() + ": " + response.body());
        System.out.println(response.body()); // RSS/XML feed
    }
}
```

Getting an error instead? See [Errors & billing](https://api.techmap.io/errors-and-billing).

## How to authenticate

Requests are authenticated and billed by the marketplace you subscribe through. The base URL, the key and the plans depend on that marketplace.

### RapidAPI

- **Base URL:** `https://job-postings-rss-feed.p.rapidapi.com`
- **Key:** query parameter `rapidapi-key=YOUR_API_KEY` in the request URL - no header needed. This lets you paste the feed URL into any job board importer that only accepts a URL.
- **Where to find the key:** [RapidAPI listing](https://rapidapi.com/techmap-io-techmap-io-default/api/job-postings-rss-feed) → *Endpoints* tab → code snippet → value of `X-RapidAPI-Key` - one key per RapidAPI application (see [RapidAPI docs](https://docs.rapidapi.com/docs/keys-and-key-rotation)).
- **Plans and prices:** [RapidAPI pricing page](https://rapidapi.com/techmap-io-techmap-io-default/api/job-postings-rss-feed/pricing)
- Calling the backend directly (without RapidAPI) returns **401**.

## Errors

All errors return JSON with a `message` field.

| Status | Cause | Solution |
|---|---|---|
| **400** Bad Request | A parameter value could not be parsed, e.g. an unknown `countryCode` or an invalid date. | Check the value against the parameter description. The `message` names the invalid parameter. |
| **401** Unauthorized | The key is missing or invalid, or the request was sent directly to the backend instead of RapidAPI. | Send your key in the query parameter `rapidapi-key` and use the base URL `https://job-postings-rss-feed.p.rapidapi.com`. Copy the key again from the RapidAPI listing if it was rotated. |
| **403** Forbidden | You are not subscribed to this API ("You are not subscribed to this API."). | Subscribe to the Basic plan. |
| **404** Not Found | The endpoint path does not exist (typo, wrong API version) or a required search parameter is missing. | Check the path and add at least one search parameter (e.g. `countryCode`). The `message` lists the allowed parameters. |
| **405** Method Not Allowed | Another HTTP method than GET was used. | Use GET. |
| **429** Too Many Requests | Too many requests in a short time window (rate limit of your RapidAPI plan, e.g. 1 request/second on Basic). This is **not** a monthly limit - the plans have no hard limit, extra requests are billed as overage. RapidAPI also answers 429 after repeated calls with an invalid key. | Slow down and retry with exponential backoff (e.g. 1 s, 2 s, 4 s). If it persists, check that your key is valid. |
| **500** Internal Server Error | An unexpected error on our side. | Retry once. If it persists, contact data@techmap.io with the full request URL (without your key). |
| **502/504** Bad Gateway / Gateway Timeout | RapidAPI did not get a timely answer from the backend, typically for very broad queries. | Narrow the query (more filters, shorter date range) and retry. |
| **503** Service Unavailable | The search backend is temporarily unavailable, or it could only answer partially (some index shards failed or timed out). Partial results are never returned as 200. | Retry later with exponential backoff. |
| **509** Bandwidth Limit Exceeded | The response would be larger than 6 MB. | Use a smaller `pageSize` or narrow the query. |

Plans, included requests and overage: [Errors & billing](https://api.techmap.io/errors-and-billing).

## Changelog

- **2026-10-06 (v1.6.2)**: A **partial answer from the search backend** (some index shards failed or timed out) now returns **503** instead of a 200 with incomplete results. A 200 response is always complete, so you can safely treat missing postings as removed.
- **2026-10-03 (v1.6.1)**: Documentation release. Unknown `countryCode` values (e.g. `zz`, `00`) and invalid dates or date ranges now return **400** with a clear message. **All error responses now return valid JSON** with a `message` field (some were plain text or invalid JSON before). Added **Quickstart**, **How to authenticate** (per marketplace) and **Errors & billing**. Fixed the server URL (`https://job-postings-rss-feed.p.rapidapi.com`) and documented the key as query parameter `rapidapi-key` (removed the misleading Bearer header from the examples). The feed's channel `<link>` now shows the public feed URL without your key.
- **2026-06-03 (v1.6)**: Fixed **Boolean prefix operators** (`+`/`-`) not applying correctly with multiple comma-separated values. Multiple values per field now use AND logic between fields and OR logic within a field.
- **2025-04-22 (v1.2)**: Added **isDuplicate parameter** for excluding potential duplicates.
- **2025-03-24 (v1.1)**: Added **date range parameter** for querying specific time periods.
- **2025-03-17 (v1.0)**: Published **first version**.


## Endpoints

### GET /api/rss/v1/jobs_full - Get job postings as RSS feed

Use this endpoint to import job postings into job board software or feed readers - the key goes into the URL, so the feed URL can be pasted anywhere. For JSON, use the Job Postings API. This endpoint returns an **RSS feed** containing job postings, including **full job descriptions**, based on the specified search query. Results can be paginated for efficient data retrieval.
The RSS/XML data can be easily customized to meet specific needs and seamlessly integrated into a job board to backfill it with fresh, relevant job postings.

Parameters:

- `dateCreated` (query, string): The day the job posting was created / posted on using the format `YYYY-MM-DD` or `YYYY-MM`. If empty, the current day minus 2 days is used.
- `dateCreatedMin` (query, string): The starting date for a date range search of when the job posting was created or posted, using the format `YYYY-MM-DD`. Only used if `dateCreated` is empty; `dateCreatedMin` and `dateCreatedMax` must be used together.
- `dateCreatedMax` (query, string): The ending date for a date range search of when the job posting was created or posted, using the format `YYYY-MM-DD`. Only used if `dateCreated` is empty; `dateCreatedMin` and `dateCreatedMax` must be used together.
- `countryCode` (query, string): The country the job is located in described by a 2-letter country code from ISO 3166-1 alpha-2. Internally, we lower-case the countryCode and convert 'gb' into 'uk' and 'el' into 'gr' - you can use both spellings.
- `city` (query, string): The city the workplace is located in, extracted from the job posting or geo-location.
- `title` (query, string): Free-text search within the title of the job postings.
- `skills` (query, string): The skills, keywords, or tags associated with the job posting.
- `language` (query, string): The language the job posting is written in described by a 2-letter language code from ISO 639-1 such as 'en', 'de' or 'zh'.
- `workPlace` (query, string): The workplace of the job, extracted from the job posting such as remote, hybrid, onsite, field, offshore, etc.
- `contractType` (query, string): The type of employment contract extracted from the job posting such as permanent, temporary, internship, etc.
- `workType` (query, string): The type of work duration extracted from the job posting such as fulltime, parttime, flextime, etc.
- `hasSalary` (query, string): A flag indicating if the job posting contains salary information.
- `minSalary` (query, number): The minimum salary of the job posting. Can be yearly, monthly, or hourly and any currency.
- `isDirect` (query, string): A flag indicating if the job posting URL links directly to the company's website or ATS career page.
- `isDuplicate` (query, string): A flag indicating whether the job posting is considered a duplicate of another, either within the same source or across multiple sources. Note: We currently err on the safe side, resulting in more false duplicates than there are.
- `isRecruiter` (query, string): A flag indicating if the job posting was posted by a recruiting firm.
- `industry` (query, string): The industry extracted from the job posting or categorization in the job board, such as advertising, agriculture, it, healthcare, etc.
- `company` (query, string): The company that posted the job posting (can be a recruiting firm).
- `occupation` (query, string): The occupation type extracted from the job title reduced to a stem form incl. several synonyms. For example: programmer, executive, manager, engineer, nurse, etc.
- `timezone` (query, string): The timezone the job is located in such as CET, PST, or UTC
- `timezoneOffset` (query, integer): The numeric offset of the timezone from UTC.
- `timezoneMin` (query, integer): The minimum numeric offset of the timezone from UTC. Requires a 'timezoneMax' value greater than 'timezoneMin' to search in a timezone range.
- `timezoneMax` (query, integer): The maximum numeric offset of the timezone from UTC. Must be larger than 'timezoneMin' to search in a timezone range.
- `geoPointLat` (query, number): The geographic latitude of a GeoPoint used in a distance search.
- `geoPointLng` (query, number): The geographic longitude of a GeoPoint used in a distance search.
- `geoDistance` (query, string): The distance from a GeoPoint specified with 'geoPointLat' and 'geoPointLng'.
- `geoTopLeftLat` (query, number): The geographic latitude of the top left GeoPoint in a bounding box search.
- `geoTopLeftLng` (query, number): The geographic longitude of the top left GeoPoint in a bounding box search.
- `geoBottomRightLat` (query, number): The geographic latitude of the bottom right GeoPoint in a bounding box search.
- `geoBottomRightLng` (query, number): The geographic longitude of the bottom right GeoPoint in a bounding box search.
- `page` (query, integer): The page of the page-based pagination search results starting at 1. Defaults to 1 if not stated. Pagination is included from the Pro plan on - with smaller plans you always get page 1.
- `pageSize` (query, integer): The number of job postings per request. Max and default depend on your plan: Basic 10, Pro 10, Ultra 100, Mega 1000.

Responses: 200, 400, 401, 403, 404, 405, 429, 500, 503, 509