# Remote Jobs API: RemoteOK & Jobicy Postings (`tabulary/remote-jobs-feed`) Actor

Merged, de-duplicated remote job postings from the RemoteOK and Jobicy public APIs, normalized to one schema with salary, tags and location. Optional keyword filter and only-new mode for hourly schedules. No login or API key.

- **URL**: https://apify.com/tabulary/remote-jobs-feed.md
- **Developed by:** [Tabulary](https://apify.com/tabulary) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 job postings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Remote Jobs API: RemoteOK & Jobicy Postings do?

This Actor returns **remote jobs** merged from two official, keyless public APIs — [RemoteOK](https://remoteok.com/api) and [Jobicy](https://jobi.cy/apidocs) — normalized into one clean schema with salary, tags, employment type and location. It's built for job boards, newsletters, recruiters, market researchers and AI agents that want a **remote jobs feed** or **remote job postings** without scraping either site or juggling two different response shapes. Postings that appear on both boards are de-duplicated by company and title, and every record keeps a link back to its original source page, as both APIs' terms require.

### What you get

- Title, company, location, employment type and salary (min, max, currency, period) where the source discloses it — `null` otherwise, never guessed.
- Category/skill tags, posting date, the source board, and both the canonical listing URL and the apply link.
- A **keyword filter** across title, company and tags, and a choice of one or both boards per run.
- An **only-new-since-last-run** mode for hourly or daily schedules, so repeat runs deliver just the new postings.
- JSON, CSV or Excel export, Google Sheets, and use from AI agents through the Apify MCP server.

### How much does it cost?

You pay per job posting saved, with no monthly fee: **$1.50 per 1,000 postings** on Apify's free plan, and 10–40% less on paid Apify plans. Each run also costs $0.001 to start. Apify's free plan includes $5 of credit every month, enough for about 3,300 postings. Prices as of October 2026; the price shown on this page is the one that applies.

| Use | Postings | Cost on the free plan |
|---|---|---|
| One search | 100 | about $0.15 |
| A daily scheduled run, about 50 new postings a day | about 1,500 a month | about $2.25 a month |

Set **Maximum cost per run** to cap any run; the Actor stops cleanly at the cap and keeps everything it saved.

### Ready-made inputs

Paste one of these into the JSON input tab, or set the same fields in the form. Each returned
results in a live test on 22 October 2026.

**All new remote jobs from both boards, newest first** · [open this example](https://apify.com/tabulary/remote-jobs-feed/examples/remote-jobs-newest)

```json
{ "maxItems": 100 }
```

**Remote Python developer jobs** · [open this example](https://apify.com/tabulary/remote-jobs-feed/examples/remote-python-jobs)

```json
{ "keyword": "python", "maxItems": 100 }
```

**Daily alert: new remote designer jobs** (schedule it every morning) · [open this example](https://apify.com/tabulary/remote-jobs-feed/examples/remote-designer-job-alerts)

```json
{ "keyword": "designer", "onlyNewSinceLastRun": true, "maxItems": 200 }
```

**Remote marketing jobs** · [open this example](https://apify.com/tabulary/remote-jobs-feed/examples/remote-marketing-jobs)

```json
{ "keyword": "marketing", "maxItems": 100 }
```

### Job alerts: only new since the last run

1. Set your keyword and sources and turn on **Only new since last run**.
2. Save it as a task and add an Apify **Schedule** (hourly or daily).
3. Connect the output: Apify's built-in Slack and email notifications, a webhook, or Make, Zapier
   and n8n to post each new job to a channel, a sheet or a job board.

Each run returns only postings that earlier runs with the same keyword and sources have not
delivered, so you pay only for new ones. Postings cut off by your maximum results or spending limit
come in the next run.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `sources` | array | `["remoteok", "jobicy"]` | Which boards to pull from. |
| `keyword` | string | `""` (none) | Keep only postings whose title, company or tags contain this word. |
| `maxItems` | integer | `30` | Stop after this many postings. Each saved posting is one billable item. |
| `onlyNewSinceLastRun` | boolean | `false` | Skip postings already saved by an earlier run with the same sources and keyword. |

### Output

One dataset item per job posting. A real item from the local test run:

```json
{
  "source": "jobicy",
  "source_id": "156261",
  "title": "Mid-Market Account Executive",
  "company": "MaintainX",
  "company_logo": "https://jobicy.com/data/server-nyc0409/galaxy/mercury/2025/08/f0177662-221.png",
  "location": "USA",
  "employment_type": "Full-Time",
  "tags": ["Sales"],
  "salary_min": 153000,
  "salary_max": 210000,
  "salary_currency": "CAD",
  "salary_period": "yearly",
  "posted_at": "2026-10-21T18:39:51.000Z",
  "url": "https://jobicy.com/jobs/156261-mid-market-account-executive-7",
  "apply_url": "https://jobicy.com/jobs/156261-mid-market-account-executive-7",
  "description": "MaintainX is a leading mobile-first work execution platform..."
}
```

`source` is `"remoteok"` or `"jobicy"`. `salary_min`/`salary_max`/`salary_currency`/`salary_period` are `null` when the employer didn't disclose a salary (RemoteOK rarely states a currency or period, so those two are always `null` for RemoteOK records). `posted_at` is ISO 8601. `url` is always the source's own job page, as RemoteOK's and Jobicy's API terms require; `apply_url` points at the employer's application page when the source provides one, otherwise it matches `url`. Any e-mail addresses or phone numbers inside `description` are replaced with `[email removed]` / `[phone removed]`.

### Use it from AI agents

Add the Actor to Claude, ChatGPT, Cursor or any MCP client through the Apify MCP server
(`https://mcp.apify.com?tools=tabulary/remote-jobs-feed`). Ask in plain language, for
example: "Find remote Python jobs posted in the last week." The agent fills in the input and
gets structured postings back.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/tabulary~remote-jobs-feed/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sources": ["remoteok", "jobicy"], "keyword": "python", "maxItems": 50}'
```

The same works with the Apify Python and JavaScript clients. See the API tab for details.

### Data source and limits

- [RemoteOK API](https://remoteok.com/api): keyless, returns its latest roughly 100 open postings per request, no further pagination. RemoteOK's terms require a followed link back to the RemoteOK URL and crediting RemoteOK as a source, which this Actor does by keeping each RemoteOK record's `url` pointed at its RemoteOK listing page.
- [Jobicy API](https://jobi.cy/apidocs): keyless, covers postings published in the last 7 days with cursor pagination. Jobicy's public API always returns its own job-page URL (a paid Jobicy key is needed for a direct employer apply link), which satisfies Jobicy's requirement that apply links keep pointing at the original Jobicy job page.
- Both sources are polled at most about once per second; the Actor backs off and retries on rate-limit or server errors.
- No personal data is requested. Any e-mail or phone number appearing in a posting's free-text description is masked.
- Not affiliated with or endorsed by RemoteOK or Jobicy.

### Other Tabulary tools

Clean data from official and public sources, priced per result:

- [UK Tenders API: Contracts Finder & Find a Tender](https://apify.com/tabulary/uk-public-tenders)
- [EU Tenders API: TED Public Procurement Notices](https://apify.com/tabulary/eu-ted-tenders)
- [SAM.gov Federal Contract Opportunities](https://apify.com/tabulary/sam-gov-contract-notices)
- [Airport METAR & TAF Weather](https://apify.com/tabulary/airport-weather-metar-taf)
- [Company Job Postings: Greenhouse, Lever, Ashby & Workable](https://apify.com/tabulary/multi-ats-job-postings)

### FAQ

**Is this data official?** Yes — every record comes straight from RemoteOK's or Jobicy's own public API, not a scrape of their web pages.

**How fresh is it?** RemoteOK's API reflects its current ~100 newest open postings; Jobicy's covers the last 7 days. Run the Actor on a schedule with **Only new since last run** turned on for a live feed.

**Why are some salary fields `null`?** Because the employer didn't disclose them. RemoteOK rarely states a currency or pay period at all, so those two fields are always `null` for RemoteOK records.

**Something broke?** Open an issue on the Issues tab. The Actor is tested daily.

### Changelog

- **2026-10-22:** First version: merged RemoteOK and Jobicy feeds, de-duplicated by company and title, keyword filter, and an only-new-since-last-run monitor for scheduled alerts.

### About Tabulary

This tool is part of [Tabulary](https://apify.com/tabulary): clean tables from official public
sources. Every Tabulary tool uses the source's official API or open data where one exists,
collects no personal data, and is tested on Apify every day. Questions or ideas? Open an issue on
the Issues tab.

# Actor input Schema

## `sources` (type: `array`):

Which boards to pull from. Leave both checked for the merged, de-duplicated feed.

## `keyword` (type: `string`):

Optional. Keep only jobs whose title, company or tags contain this word (case-insensitive). Leave empty for everything.

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

Stop after this many job postings. Each saved posting is one billable dataset item.

## `onlyNewSinceLastRun` (type: `boolean`):

For scheduled runs: skip postings already saved by an earlier run with the same sources and keyword. Good for hourly alerts.

## Actor input object example

```json
{
  "sources": [
    "remoteok",
    "jobicy"
  ],
  "keyword": "",
  "maxItems": 30,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

## `overview` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tabulary/remote-jobs-feed").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("tabulary/remote-jobs-feed").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 '{}' |
apify call tabulary/remote-jobs-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tabulary/remote-jobs-feed"
        }
    }
}
```

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/7JG3XekSOPHFCgOiA/builds/KxUJ2omDQzllJf8tU/openapi.json