# International Job Postings API - Daily Global Jobs Data (`nabeelbaghoor/international-job-postings-api`) Actor

Search the daily international job postings API and export structured job data from around the world - title, company, city, country, skills, workplace type, salary flag, posting date and apply link. Filter by country, city, title, skills, workplace and date. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/international-job-postings-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Jobs, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$12.00 / 1,000 job 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/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

## International Job Postings API - daily global jobs data

**International Job Postings API** turns a worldwide daily job postings feed into a clean, structured dataset. Filter by country, city, title, skills and date, and get back job postings from across the globe - title, company, city, country, skills, workplace type, salary flag, posting date and a direct apply link - ready to export as JSON, CSV or Excel.

Bring your own API key (a RapidAPI key subscribed to the Daily International Job Postings API) and pay only for the results you keep.

### Why use this actor?

- **Global daily coverage** - millions of job postings crawled daily from job boards and company career pages across dozens of countries, refreshed every day.
- **Structured output** - title, company, city, country, industry, skills, workplace type, contract type, career level, salary flag, language, posting date, description and apply link, parsed into flat columns.
- **Precise filters** - job title, skills, company, country, city, workplace type, contract type, career level, salary presence and a posting-date range.
- **Rich search operators** - the title and skills fields support OR (comma), exclude (`-` prefix) and exact phrase (quotes).
- **Pay per result** - you are charged only for the postings actually returned.

### Use cases

- **Labor market research** - track hiring demand by country, city, skill and date.
- **Recruiting and sourcing** - find who is hiring for which roles worldwide.
- **Skills and tech trends** - measure demand for specific skills over time and geography.
- **Lead generation** - a company that is hiring is a company that is buying.
- **Job alert automations** - schedule daily runs and push new matches to Slack, email or your ATS.

### Input

Configure everything from the visual editor - every filter is a proper field, no code needed. Example JSON input:

```json
{
  "title": "data engineer",
  "skills": "Python,Spark",
  "countryCode": "de",
  "dateCreatedMin": "2026-07-01",
  "maxResults": 100,
  "apiKey": "YOUR_API_KEY"
}
````

### Output

One clean JSON object per job:

```json
{
  "job_title": "Senior Data Engineer",
  "company_name": "Acme GmbH",
  "city": "Berlin",
  "country_code": "de",
  "workplace": "hybrid",
  "contract_type": "permanent",
  "career_level": "senior",
  "industry": "Information Technology",
  "skills": "Python; Spark; AWS",
  "has_salary": true,
  "min_salary": 75000,
  "language": "en",
  "date_created": "2026-07-22T00:00:00Z",
  "apply_link": "https://acme.de/careers/senior-data-engineer",
  "description": "We are looking for a Senior Data Engineer...",
  "job_id": "abc123"
}
```

### Do I need an API key?

Yes. This actor calls the daily international job postings API on your behalf, which requires your own API key. Subscribe to the Daily International Job Postings API on RapidAPI (a free basic plan is available), copy your RapidAPI key, paste it into the **API key** field, and run. Your key is stored securely and never logged.

### Pay per result

You pay only for the job postings the actor actually returns - no subscriptions, no minimums. Set **Maximum results** to cap each run's spend exactly.

### FAQ

#### What is the International Job Postings API?

The International Job Postings API is a global, daily-refreshed job postings feed built on OpenSearch. It returns job postings as structured data - title, company, city, country, skills, workplace type, salary flag, posting date and apply link - crawled daily from job boards and company career pages worldwide, so you can pull international hiring data without scraping each source.

#### Where does the data come from?

From a worldwide crawl of job boards and company career pages, normalized daily into a single schema with consistent company, location, skill and date fields, plus a schema.org JobPosting representation for each listing.

#### What filters can I use?

Job title, skills, company, country, city, workplace type (remote, hybrid, onsite, field, offshore), contract type, career level, salary presence, and a posting-date range. The title and skills fields support OR (comma), NOT (`-` prefix) and exact-phrase (quotes) operators.

#### How many results can I get per run?

As many as your search matches, collected 10 per page. Use **Maximum results** to set an exact cap. For very large pulls, split the search by country, city or date range.

#### How much does it cost?

Pricing is pay-per-result: a small fixed amount for every posting returned, plus standard Apify platform usage, plus your own API usage (billed by the provider against your RapidAPI key). A run that returns nothing costs almost nothing.

#### Why should I set a date range?

If no date is specified the API defaults to recent postings (about today minus two days). Set **Posted on or after** and **Posted on or before** to target a specific window and get predictable, repeatable pulls.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run it daily and connect the dataset to Zapier, Make, n8n, webhooks or the API to pipe new jobs anywhere.

#### Is this legal?

The actor returns publicly available job postings through a licensed data API using your own key. No login-walled or personal data is collected.

### Keyword map

international job postings api, global jobs api, daily job postings api, worldwide jobs data api, job postings api, job data feed api, labor market data api, hiring data api, job listings api, skills demand api, recruiting data api, jobs data api.

### Support and feedback

Found an issue or missing a filter? Open an issue in the **Issues** tab - it is monitored daily.

# Actor input Schema

## `title` (type: `string`):

Filter by words in the job title, e.g. `data engineer`, `nurse`, `sales manager`. Supports comma for OR, `-` prefix to exclude, quotes for exact phrase.

## `skills` (type: `string`):

Filter by required skills, e.g. `Python,Spark`. Comma-separated values are matched as OR.

## `company` (type: `string`):

Filter to a single company by name. Leave empty to include all companies.

## `countryCode` (type: `string`):

Two-letter country code to filter by. Leave empty to include all countries.

## `city` (type: `string`):

City name to filter by, e.g. `Berlin`, `New York`. Leave empty to include all cities.

## `workPlace` (type: `string`):

Filter by where the work is performed.

## `contractType` (type: `string`):

Filter by contract type.

## `careerLevel` (type: `string`):

Filter by seniority.

## `hasSalary` (type: `boolean`):

Return only postings that include salary information.

## `dateCreatedMin` (type: `string`):

Earliest posting date to include, in YYYY-MM-DD format, e.g. `2026-07-01`. If left empty the API defaults to recent postings (today minus 2 days).

## `dateCreatedMax` (type: `string`):

Latest posting date to include, in YYYY-MM-DD format, e.g. `2026-07-24`. Leave empty for no upper bound.

## `maxResults` (type: `integer`):

Stop after this many jobs. Results are collected 10 per page. You are charged per result returned.

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

Your own RapidAPI key subscribed to the Daily International Job Postings API. Required - the actor calls the API on your behalf using this key. Get one at rapidapi.com. Stored securely and never logged.

## Actor input object example

```json
{
  "title": "software engineer",
  "countryCode": "",
  "workPlace": "",
  "contractType": "",
  "careerLevel": "",
  "hasSalary": false,
  "maxResults": 100
}
```

# 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 = {
    "title": "software engineer",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/international-job-postings-api").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 = {
    "title": "software engineer",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/international-job-postings-api").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 '{
  "title": "software engineer",
  "maxResults": 100
}' |
apify call nabeelbaghoor/international-job-postings-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nabeelbaghoor/international-job-postings-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "International Job Postings API - Daily Global Jobs Data",
        "description": "Search the daily international job postings API and export structured job data from around the world - title, company, city, country, skills, workplace type, salary flag, posting date and apply link. Filter by country, city, title, skills, workplace and date. Pay per result. Bring your own API key.",
        "version": "0.1",
        "x-build-id": "sSwcNt2ttRsDskSXK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nabeelbaghoor~international-job-postings-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nabeelbaghoor-international-job-postings-api",
                "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/nabeelbaghoor~international-job-postings-api/runs": {
            "post": {
                "operationId": "runs-sync-nabeelbaghoor-international-job-postings-api",
                "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/nabeelbaghoor~international-job-postings-api/run-sync": {
            "post": {
                "operationId": "run-sync-nabeelbaghoor-international-job-postings-api",
                "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": {
                    "title": {
                        "title": "Job title contains",
                        "type": "string",
                        "description": "Filter by words in the job title, e.g. `data engineer`, `nurse`, `sales manager`. Supports comma for OR, `-` prefix to exclude, quotes for exact phrase."
                    },
                    "skills": {
                        "title": "Skills",
                        "type": "string",
                        "description": "Filter by required skills, e.g. `Python,Spark`. Comma-separated values are matched as OR."
                    },
                    "company": {
                        "title": "Company",
                        "type": "string",
                        "description": "Filter to a single company by name. Leave empty to include all companies."
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "",
                            "us",
                            "gb",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "ca",
                            "au",
                            "in",
                            "br",
                            "mx",
                            "sg",
                            "ae",
                            "za",
                            "jp",
                            "pl",
                            "se",
                            "ie"
                        ],
                        "type": "string",
                        "description": "Two-letter country code to filter by. Leave empty to include all countries.",
                        "default": ""
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name to filter by, e.g. `Berlin`, `New York`. Leave empty to include all cities."
                    },
                    "workPlace": {
                        "title": "Workplace type",
                        "enum": [
                            "",
                            "remote",
                            "hybrid",
                            "onsite",
                            "field",
                            "offshore"
                        ],
                        "type": "string",
                        "description": "Filter by where the work is performed.",
                        "default": ""
                    },
                    "contractType": {
                        "title": "Contract type",
                        "enum": [
                            "",
                            "permanent",
                            "temporary",
                            "freelance",
                            "contract",
                            "internship",
                            "apprenticeship",
                            "seasonal",
                            "commission",
                            "voluntary"
                        ],
                        "type": "string",
                        "description": "Filter by contract type.",
                        "default": ""
                    },
                    "careerLevel": {
                        "title": "Career level",
                        "enum": [
                            "",
                            "junior",
                            "senior",
                            "manager",
                            "director",
                            "chief",
                            "executive"
                        ],
                        "type": "string",
                        "description": "Filter by seniority.",
                        "default": ""
                    },
                    "hasSalary": {
                        "title": "Only jobs with salary",
                        "type": "boolean",
                        "description": "Return only postings that include salary information.",
                        "default": false
                    },
                    "dateCreatedMin": {
                        "title": "Posted on or after",
                        "type": "string",
                        "description": "Earliest posting date to include, in YYYY-MM-DD format, e.g. `2026-07-01`. If left empty the API defaults to recent postings (today minus 2 days)."
                    },
                    "dateCreatedMax": {
                        "title": "Posted on or before",
                        "type": "string",
                        "description": "Latest posting date to include, in YYYY-MM-DD format, e.g. `2026-07-24`. Leave empty for no upper bound."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many jobs. Results are collected 10 per page. You are charged per result returned."
                    },
                    "apiKey": {
                        "title": "API key",
                        "type": "string",
                        "description": "Your own RapidAPI key subscribed to the Daily International Job Postings API. Required - the actor calls the API on your behalf using this key. Get one at rapidapi.com. Stored securely and never logged."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
