# RemoteOK & Jobicy Remote Jobs API: Salary & Source Credit (`tamatama/remote-jobs`) Actor

RemoteOK and Jobicy remote jobs API: listings from both official APIs with title, company, location, salary, tags, date and job URL, plus source credit on every row. Keyword, region and salary filters, new-job monitoring. From $0.70 per 1,000 jobs ($1 on the Free plan, less on paid plans).

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

## Pricing

from $0.70 / 1,000 jobs

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

## RemoteOK & Jobicy Remote Jobs API: Salary & Source Credit

**RemoteOK and Jobicy remote jobs API** in one Actor: get **remote job listings** from the official **Remote OK** and **Jobicy** APIs in one call, in one clean format: title, company, allowed location, salary, tags, posting date and the job URL. Every row carries the **source credit** each board asks for, so you can use the data in a job board, newsletter, Slack alert or AI agent without breaking the boards' API terms.

**From $0.70 per 1,000 jobs** ($1 on the Free plan, less on paid plans). You only pay for jobs in the output. Filters run before charging.

### What you can use it for

- **Job seekers and communities**: a daily feed of remote engineering, marketing or design jobs, filtered by keyword, region and salary.
- **Niche job boards and newsletters**: fill your board with fresh remote jobs, with the link-back and credit already in each row.
- **Alerts**: schedule the Actor with *Only jobs not delivered in earlier runs* and send new jobs to Slack, email, Google Sheets or a webhook.
- **Market research**: which companies hire remotely, which skills are in demand, what salaries are published.
- **AI agents**: call it through the Apify API or MCP server to answer "find remote Python jobs that pay over $120k".

### Output example

One row per job (real data from a run on 2026-10-20, description shortened):

```json
{
  "id": "jobicy:155928",
  "source": "jobicy",
  "title": "Senior Software Development Engineer in Test (SDET)",
  "company": "Flex",
  "location": "Anywhere",
  "tags": ["QA & Testing"],
  "jobType": ["Full-Time"],
  "level": "Senior",
  "salaryMin": 115600,
  "salaryMax": 170000,
  "salaryCurrency": "USD",
  "salaryInterval": "year",
  "postedAt": "2026-10-19T17:09:57+00:00",
  "url": "https://jobicy.com/jobs/155928-senior-software-development-engineer-in-test-sdet-2",
  "applyUrl": "https://jobicy.com/jobs/155928-senior-software-development-engineer-in-test-sdet-2",
  "description": null,
  "attribution": { "name": "Jobicy", "url": "https://jobicy.com" },
  "change": null,
  "scrapedAt": "2026-10-20T05:04:43+00:00"
}
```

### How to use

1. Keep both **Job boards** selected (or pick one).
2. Add **keywords** such as `engineer`, `python` or `marketing` (matched as whole words in the title and tags), and optionally a region or a minimum salary.
3. Click **Start**. The default input returns 20 jobs in a few seconds. Download the results as JSON, CSV or Excel, or read them through the API.

For a feed of new jobs, turn on **Only jobs not delivered in earlier runs** and add a schedule (for example every 6 hours).

### Input

| Field | What it does |
|---|---|
| Job boards | `remoteok`, `jobicy` or both (default). |
| Title or tag contains | Any of these words in the title or tags, matched as whole words (`engineer` does not match `Engineering`; add both if you want both). Empty = all jobs. |
| Title must not contain | Drop jobs with these words in the title (e.g. `senior`, `intern`). |
| Location contains | Any of these in the allowed location, e.g. `USA`, `Europe`, `Anywhere`. Jobs with no location count as `Anywhere`. |
| Minimum yearly salary (USD) | Keep only jobs with a published yearly USD salary at or above this amount. |
| Posted within (days) | Only jobs published in the last N days. |
| Max jobs | Newest first. 0 = all matching jobs. |
| Include job description | Adds the full description as plain text. |
| Only jobs not delivered in earlier runs / Monitor name | Monitoring mode: later runs return only jobs you have not received yet (`change = "new"`). Use one monitor name per saved search. |

### Pricing

Pay per event: **$0.001 per job** in the output on the Free plan (`job` event), lower on paid Apify plans (Bronze $0.0009, Silver $0.0008, Gold and above $0.0007), plus Apify's start fee of $0.00005 per GB of memory per run (the default 512 MB counts as one).

Examples: the default input (20 jobs) costs about $0.02. A daily alert that finds 30 new jobs costs about $0.03 per day, under $1 per month. Set a maximum cost per run in the run options; the Actor stops adding jobs when the cap is reached.

### Data sources and terms

The Actor reads only the official public APIs, never the websites:

- **Remote OK** – `https://remoteok.com/api`. Remote OK's API terms ask you to **link back to the job's URL on Remote OK (a normal, followed link, not `nofollow`) and mention Remote OK as the source**, and not to use the Remote OK logo without their written permission. The `url` and `attribution` fields give you what you need. See https://remoteok.com/api.
- **Jobicy** – `https://jobicy.com/api/jobs`. Jobicy allows storing and redistributing its job data in your own products, on the condition that you **credit Jobicy with a direct link** and **send apply buttons to the original job URL** (`applyUrl`), and that automated syncs happen **at most once per hour**. The Actor caches both boards' responses in your own Apify storage (key-value store `remote-jobs-cache`) for one hour, so runs you start more often reuse them; the hour is counted per Apify account. See https://jobicy.com/jobs-rss-feed.

If you publish the jobs, keep the `url` link and the source name next to each job. Remote OK returns its latest ~100 jobs per request; Jobicy returns jobs from roughly the last 7 days (up to 1,000, in 5 pages of 200).

### Limits

- Both APIs list **recent** jobs only, so this is a feed of current openings, not an archive.
- Monitoring reports **new** jobs only. A job that drops out of a feed is not necessarily closed, so the Actor does not guess.
- Salaries are published for a minority of jobs (about 1 in 5 on Remote OK). Remote OK salaries are yearly USD. Jobicy salaries keep their own currency and interval.
- The same job (same company and title) posted on both boards is output once; the other board is listed in `alsoOn`. Two jobs with the same title on one board (e.g. for two countries) are both kept.
- Text that the source sent with broken characters is repaired when possible; a few mixed cases stay as sent.
- With **Max jobs** at 200 or less, the Actor reads only the newest page (200 jobs) of Jobicy, so filters see fewer Jobicy jobs. Set 0 or more than 200 to read up to 1,000.
- A board that rate-limits (HTTP 429), errors (5xx) or sends a block page instead of JSON is retried twice, waiting as long as it asks (up to 2 minutes).
- If one board is down, the run still returns the other board's jobs and explains the failure in the `SUMMARY` record. If both fail, the run fails with a message naming them.

### FAQ

**How do I get only new jobs every day?** Turn on *Only jobs not delivered in earlier runs*, save the input as a task and add a schedule. Each run outputs only jobs you have not received yet.

**Can I use it from Make, n8n, Zapier or code?** Yes. Use the Apify integration for Make, n8n or Zapier, or call the Actor through the Apify API (`run-sync-get-dataset-items`) from Python or JavaScript, or from an AI agent through the Apify MCP server.

**Why are some locations empty?** Remote OK often leaves the location blank, which means the job is open worldwide. These jobs match the `Anywhere` location filter.

### Related Actors by the same author

| Actor | What it does |
|---|---|
| [ATS Jobs](https://apify.com/tamatama/ats-jobs) | Jobs straight from company career boards (Greenhouse, Lever, Ashby, Recruitee, Personio, Teamtailor), with new and closed job monitoring. |
| [Website Change Monitor](https://apify.com/tamatama/website-change-monitor) | Watch any careers page or job page that has no API and get the added and removed lines. |
| [PDF to Markdown](https://apify.com/tamatama/doc-to-markdown) | PDF and Office files to Markdown or RAG chunks with page numbers. |
| [PDF OCR](https://apify.com/tamatama/image-pdf-ocr) | Scans and images to text and searchable PDFs. |

### For AI Agents

Job-search agents and assistants can use this Actor as their remote-jobs tool: one call returns fresh listings from two boards, already filtered, with salary fields as numbers and a link-back in every row. No login, no API key for the boards, pay per job through Apify (pay per event), limited permissions.

**MCP** (Claude Desktop, Cursor and other MCP clients), with only this Actor as a tool:

```json
{
  "mcpServers": {
    "remote-jobs": {
      "url": "https://mcp.apify.com?tools=tamatama/remote-jobs"
    }
  }
}
```

The first connection opens an OAuth sign-in (a header `Authorization: Bearer <APIFY_TOKEN>` also works). The agent gets a tool named `tamatama--remote-jobs` (plus `get-dataset-items` for long lists). For "remote Python jobs that can pay $120k or more, open to Europe" it would send:

```json
{ "keywords": ["python"], "locationKeywords": ["europe", "anywhere"], "salaryMinUsd": 120000, "maxItems": 20 }
```

When the agent shows a job to a user, it should show the `attribution` name and the `url`: both boards ask for that credit.

**OpenAPI**: `https://api.apify.com/v2/acts/tamatama~remote-jobs/builds/default/openapi.json`. **REST**: `POST https://api.apify.com/v2/acts/tamatama~remote-jobs/run-sync-get-dataset-items` with the JSON input.

# Actor input Schema

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

Which public job board APIs to read: Remote OK (remoteok) and Jobicy (jobicy). Leave both for the widest coverage.

## `keywords` (type: `array`):

Keep jobs whose title or tags contain at least one of these words (whole words, case-insensitive), e.g. "engineer", "python", "marketing". Leave empty for all jobs.

## `excludeKeywords` (type: `array`):

Drop jobs whose title contains any of these words, e.g. "senior", "intern".

## `locationKeywords` (type: `array`):

Keep jobs whose location or allowed region contains one of these, e.g. "USA", "Europe", "Anywhere". Jobs without a location count as "Anywhere".

## `salaryMinUsd` (type: `integer`):

Keep only jobs that publish a yearly USD salary whose top of the range is at least this amount. 0 = no salary filter (jobs without a salary are kept).

## `postedWithinDays` (type: `integer`):

Keep only jobs published in the last N days. 0 = no limit.

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

Newest first. 0 = all matching jobs. You pay per job in the output.

## `includeDescription` (type: `boolean`):

Add the full job description as plain text. Makes the output much larger.

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

Monitoring mode. The first run returns all matching jobs and remembers them; later runs return only jobs you have not received yet (change = "new"). Schedule the Actor to get a feed of new remote jobs.

## `monitorName` (type: `string`):

Keeps separate memories for different searches. Use the same name in every scheduled run of the same search.

## Actor input object example

```json
{
  "sources": [
    "remoteok",
    "jobicy"
  ],
  "keywords": [
    "engineer"
  ],
  "salaryMinUsd": 0,
  "postedWithinDays": 0,
  "maxItems": 20,
  "includeDescription": false,
  "onlyNewSinceLastRun": false,
  "monitorName": "default"
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `summary` (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 = {
    "sources": [
        "remoteok",
        "jobicy"
    ],
    "keywords": [
        "engineer"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tamatama/remote-jobs").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 = {
    "sources": [
        "remoteok",
        "jobicy",
    ],
    "keywords": ["engineer"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tamatama/remote-jobs").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 '{
  "sources": [
    "remoteok",
    "jobicy"
  ],
  "keywords": [
    "engineer"
  ],
  "maxItems": 20
}' |
apify call tamatama/remote-jobs --silent --output-dataset

```

## MCP server setup

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

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/ltN203aousmsgdOuh/builds/wgHmJ1YHYuRfUVtPv/openapi.json