# RemoteOK Scraper - Remote Jobs, Salary & Tags API (`scrapers_lat/remoteok-scraper`) Actor

RemoteOK scraper and remote jobs API. Export remote job listings with company, tags, category, seniority, USD salary, apply URL, contact emails and full descriptions. 14 filters (keyword, tag, company, region, salary, date, sort). Fast JSON feed, no login or API key. JSON, CSV, Excel.

- **URL**: https://apify.com/scrapers_lat/remoteok-scraper.md
- **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community)
- **Categories:** Jobs, Business, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.15 / 1,000 results

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 Scraper - Remote Jobs, Salary & Tags API](https://scrapers.lat/banners/remoteok-scraper.png)](https://console.apify.com/actors/INWZ0Ty0algwSI9yJ/input)

## RemoteOK Scraper - Remote Jobs, Salary & Tags API

Scrape remote job listings from [RemoteOK](https://remoteok.com) into structured JSON, CSV or Excel. This RemoteOK scraper reads the live remote jobs feed and returns the position, company, tags, a derived category and seniority, the USD salary range, apply URL, contact emails and the full job description, with 14 input filters to target exactly the remote roles you want. No login or API key.

Here is one real result, with every field the actor returns (description trimmed for readability):

```json
{
  "id": "1136937",
  "position": "Solutions Delivery Manager",
  "company": "Benchling",
  "companyUrl": "https://remoteok.com/company/benchling",
  "companyLogo": null,
  "slug": "remote-solutions-delivery-manager-benchling-1136937",
  "url": "https://remoteOK.com/remote-jobs/remote-solutions-delivery-manager-benchling-1136937",
  "jobUrl": "https://remoteOK.com/remote-jobs/remote-solutions-delivery-manager-benchling-1136937",
  "applyUrl": "https://remoteOK.com/remote-jobs/remote-solutions-delivery-manager-benchling-1136937",
  "location": "Boston",
  "remote": true,
  "isWorldwide": false,
  "applicantRegion": "United States",
  "tags": ["exec", "design", "technical", "marketing", "sales", "biotech", "medical", "education", "digital nomad"],
  "category": null,
  "seniority": null,
  "employmentType": "FULL_TIME",
  "salaryMin": 150000,
  "salaryMax": 200000,
  "salaryCurrency": "USD",
  "salaryText": "$150,000 - $200,000",
  "salaryDisclosed": true,
  "isVerified": false,
  "isOriginalPost": false,
  "postedAt": "2026-08-18T08:00:07+00:00",
  "postedEpoch": 1787040007,
  "validThrough": "2026-11-16T08:00:07+00:00",
  "contactEmails": null,
  "applyLinks": null,
  "excerpt": "We are rebuilding biotech for the AI era. When a breakthrough is delayed, the world waits...",
  "description": "We are rebuilding biotech for the AI era.\n\nWhen a breakthrough is delayed, the world waits...",
  "rawDescription": "<p>We are rebuilding biotech for the AI era...</p>",
  "observedAt": "2026-08-26T08:37:04.434Z",
  "error": null
}
```

The most complete RemoteOK scraper on Apify. It returns every field RemoteOK exposes for a listing, plus derived fields other scrapers do not give you (`category`, `seniority`, `isWorldwide`, `salaryCurrency`, `salaryDisclosed`, `excerpt`, extracted `contactEmails` and off-platform `applyLinks`), and an optional detail add-on for `employmentType`, `applicantRegion`, `validThrough` and `companyUrl`. Fourteen input filters let you target the exact remote roles you need.

**📥 [Input](https://apify.com/scrapers_lat/remoteok-scraper/input-schema) · 📤 [Output](https://apify.com/scrapers_lat/remoteok-scraper/output-schema) · 💰 [Pricing](https://apify.com/scrapers_lat/remoteok-scraper/pricing) · ▶️ [Examples](https://apify.com/scrapers_lat/remoteok-scraper/examples)**

![Apify](https://img.shields.io/badge/Platform-Apify-1CE1CE?logo=apify\&logoColor=white)
![Coverage](https://img.shields.io/badge/Coverage-Worldwide-blue)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)
![Billing](https://img.shields.io/badge/Billing-Pay%20per%20result-brightgreen)

### Table of contents

- [What it does](#what-it-does)
- [How we compare](#how-we-compare)
- [Use cases](#use-cases)
- [Quickstart](#quickstart)
- [Input reference](#input-reference)
- [Output reference](#output-reference)
- [Example output record](#example-output-record)
- [Run via API and CLI](#run-via-api-and-cli)
- [Fetch results](#fetch-results)
- [Billing and limits](#billing-and-limits)
- [FAQ and troubleshooting](#faq-and-troubleshooting)

### What it does

This is a remote jobs scraper and RemoteOK API export tool. It reads RemoteOK's live remote jobs feed, applies the filters you pass, and writes one normalized record per job to the run's dataset. Each record carries the position, company, RemoteOK tags, a derived `category` and `seniority`, the location, the published USD salary split into `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryText`, the apply URL, both a clean plain-text `description` and the raw HTML `rawDescription`, plus a short `excerpt`. It also extracts public `contactEmails` and off-platform `applyLinks` out of each description, which most remote job board scrapers do not. Posting dates are normalized to ISO 8601 with a Unix `postedEpoch`, and any value RemoteOK does not publish is returned as `null`.

Turn on the optional detail add-on (`enrichDetails`) and each job is enriched from its RemoteOK page with `employmentType`, `applicantRegion` (the hiring-region requirement, for example United States or Anywhere), `validThrough` (the listing expiry) and `companyUrl`.

The scraper is HTTP-only and reads RemoteOK's JSON feed directly, so a typical run finishes in seconds. RemoteOK's public feed exposes roughly the 100 most recent postings; the actor filters and sorts across all of them.

### How we compare

There are several RemoteOK scrapers on Apify. This one is built to be a strict superset on filters and fields, while staying honest about where others win.

| Capability | scrapers_lat (this actor) | newbs/remoteok-premium-job-scraper | fetch_cat/remoteok-jobs-scraper | rocketapi/remoteok-jobs-scraper | pixflor/remote-jobs-aggregator |
|---|---|---|---|---|---|
| Input filters | 14 (keyword, exclude, tag, company, location, remote region, seniority, min/max salary, salary-only, posted-after, posted-within-days, sort, max) | 6 | ~13 | 5 | ~11 |
| Contact emails from description | Yes | No | No | No | No |
| Off-platform apply links | Yes | No | No | No | No |
| Derived category and seniority | Yes (from title) | No | category only | No | category + seniority |
| salaryCurrency / salaryDisclosed | Yes / Yes | No | Yes / Yes | No | Yes / No |
| Verified-listing flag | Yes | No | No | No | No |
| Detail add-on (employmentType, applicantRegion, validThrough, companyUrl) | Yes (opt-in) | employmentType only | No | No | employmentType, locationRestrictions, expiresAt |
| Transport | JSON feed (fast) | browser | JSON feed | JSON feed | multi-board |
| Multi-board (WWR, Himalayas) | No, RemoteOK only | No | No | No | Yes |
| Adoption | growing | ~102 users (most adopted) | ~8 users | ~2 users | ~2 users |
| Price | per-result (see pricing tab) | $29/mo rental + usage | ~$0.30-0.575 / 1k (cheaper) | $4 / 1k | ~$2 / 1k |

Honest notes: `newbs/remoteok-premium-job-scraper` has the largest user base today and bundles a structured `baseSalary` object; `fetch_cat/remoteok-jobs-scraper` is cheaper per result and also uses the JSON feed; `pixflor/remote-jobs-aggregator` covers multiple boards (We Work Remotely, Himalayas, Arbeitnow), which this RemoteOK-only actor does not. Where we win: more input filters, unique `contactEmails` and `applyLinks`, a verified flag, and derived category/seniority, all from a fast JSON feed.

### Use cases

- **Job aggregators and remote job boards:** pull a clean, deduplicated remote jobs feed from RemoteOK with tags, category, salary and apply links to power a job board or newsletter.
- **Recruiting and sourcing:** capture the company, apply URL, off-platform apply links and any public contact emails to build outreach lists for remote hiring.
- **Salary benchmarking:** filter to listings with a disclosed USD salary (`salaryOnly`) and export `salaryMin` / `salaryMax` for remote compensation research by role, tag or seniority.
- **Remote-work and labor-market research:** track which categories, regions and tech stacks are hiring remotely over time using `category`, `seniority`, `tags` and `postedAt`.
- **Lead generation:** find companies actively hiring for a stack (`tags`), region (`remoteRegion`) or seniority and reach the hiring team via `companyUrl` and extracted emails.

### Quickstart

Open the actor, paste this into the input, and press Run. It returns the 10 most recent remote engineering jobs.

```json
{
  "searchTerms": ["engineer"],
  "sortBy": "newest",
  "maxJobs": 10
}
```

Leave every filter empty to collect the full live feed. Combine filters to narrow: for example the highest-paying US remote jobs with a disclosed salary.

```json
{
  "remoteRegion": "usa",
  "salaryOnly": true,
  "sortBy": "salary_high",
  "maxJobs": 25
}
```

### Input reference

Every field is optional. With an empty input the actor returns the full live RemoteOK feed.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchTerms` | string\[] | no | `["engineer"]` | Keep a job when its position, company, tags or description matches ANY term (case-insensitive). Empty keeps every job. |
| `excludeTerms` | string\[] | no | (none) | Drop a job when it matches ANY term (case-insensitive). |
| `tags` | string\[] | no | (none) | Keep only jobs carrying at least one of these RemoteOK tags, for example `react`, `golang`, `design`, `senior`. |
| `company` | string | no | (empty) | Keep only jobs whose company name contains this text (case-insensitive). |
| `location` | string | no | (empty) | Keep only jobs whose location text contains this value, for example `Europe`, `United States`. |
| `remoteRegion` | string | no | `any` | `worldwide`, `usa` or `europe` to restrict by the listing's hiring region. |
| `seniority` | string | no | `any` | `junior`, `mid`, `senior` or `lead`, derived from tags and title. |
| `minSalary` | integer | no | (none) | Keep only jobs whose published maximum salary is at or above this annual USD amount. |
| `maxSalary` | integer | no | (none) | Keep only jobs whose published minimum salary is at or below this annual USD amount. |
| `salaryOnly` | boolean | no | `false` | Keep only listings that publish a salary range. |
| `postedAfter` | string | no | (empty) | Keep only jobs posted on or after this date (`YYYY-MM-DD`). |
| `postedWithinDays` | integer | no | (none) | Keep only jobs posted within this many days of now. |
| `sortBy` | string | no | `default` | `newest`, `oldest`, `salary_high` or `salary_low`. |
| `maxJobs` | integer | no | `10` | Maximum number of matching jobs to return. |
| `enrichDetails` | boolean | no | `false` | Fetch each job's page to add `employmentType`, `applicantRegion`, `validThrough` and `companyUrl`. Paid plans only; billed as a `details` event on a successful fetch. |

### Output reference

One dataset item per job. Types: `string`, `integer`, `boolean`, `string[]`, or `null` when the source value is absent.

| Field | Type | Description |
|---|---|---|
| `id` | string | RemoteOK job id (unique per listing). |
| `position` | string | Job title / position. |
| `company` | string | Hiring company name. |
| `companyUrl` | string | RemoteOK company page URL. Populated only when `enrichDetails` is on, else `null`. |
| `companyLogo` | string | Company logo URL when RemoteOK publishes one (often `null`). |
| `slug` | string | RemoteOK URL slug. |
| `url` / `jobUrl` | string | RemoteOK listing page URL. |
| `applyUrl` | string | URL to apply for the job. |
| `location` | string | Location text as published, or `null`. |
| `remote` | boolean | Always `true` (all RemoteOK listings are remote). |
| `isWorldwide` | boolean | `true` when the listing is open worldwide / anywhere, else `false`. |
| `applicantRegion` | string | Hiring-region requirement (for example United States, Anywhere). `enrichDetails` only. |
| `tags` | string\[] | RemoteOK tags (skills, seniority, category). |
| `category` | string | Derived top-level category from the title (engineering, design, sales, ...), or `null`. |
| `seniority` | string | Derived seniority (junior, mid, senior, lead), or `null`. |
| `employmentType` | string | Employment type from the listing (for example FULL_TIME). `enrichDetails` only. |
| `salaryMin` | integer | Published minimum annual salary in USD, or `null`. |
| `salaryMax` | integer | Published maximum annual salary in USD, or `null`. |
| `salaryCurrency` | string | `USD` when a salary is published, else `null`. |
| `salaryText` | string | Original salary range text, for example `$150,000 - $200,000`, or `null`. |
| `salaryDisclosed` | boolean | `true` when the listing publishes a salary. |
| `isVerified` | boolean | `true` when RemoteOK flags the listing as verified. |
| `isOriginalPost` | boolean | `true` when the job was posted directly on RemoteOK (not aggregated from another board). |
| `postedAt` | string | ISO 8601 posting timestamp. |
| `postedEpoch` | integer | Posting time as a Unix epoch (seconds). |
| `validThrough` | string | Listing expiry as published by RemoteOK. `enrichDetails` only. |
| `contactEmails` | string\[] | Public contact emails found in the description, or `null`. |
| `applyLinks` | string\[] | Off-platform apply / company links found in the description, or `null`. |
| `excerpt` | string | Short plain-text excerpt of the description. |
| `description` | string | Full plain-text job description. |
| `rawDescription` | string | Raw HTML job description. |
| `observedAt` | string | ISO 8601 timestamp of when the record was collected. |
| `error` | string | `null` on success. On a failed run, a single item with a populated `error` field is written instead. |

### Example output record

Real record from a `{"salaryOnly": true, "sortBy": "salary_high", "enrichDetails": true}` run, description trimmed. See the hero example at the top for the full field set.

```json
{
  "position": "Solutions Delivery Manager",
  "company": "Benchling",
  "companyUrl": "https://remoteok.com/company/benchling",
  "location": "Boston",
  "applicantRegion": "United States",
  "employmentType": "FULL_TIME",
  "salaryMin": 150000,
  "salaryMax": 200000,
  "salaryCurrency": "USD",
  "salaryText": "$150,000 - $200,000",
  "salaryDisclosed": true,
  "postedAt": "2026-08-18T08:00:07+00:00",
  "validThrough": "2026-11-16T08:00:07+00:00",
  "tags": ["exec", "design", "technical", "marketing", "sales", "biotech", "medical", "education", "digital nomad"],
  "error": null
}
```

### Run via API and CLI

Start a run and read the dataset. Replace `<TOKEN>` with your Apify API token.

Run synchronously and get dataset items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~remoteok-scraper/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["engineer"],"tags":["react"],"salaryOnly":true,"maxJobs":25}'
```

Start a run asynchronously:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~remoteok-scraper/runs?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"remoteRegion":"europe","minSalary":100000,"sortBy":"salary_high","maxJobs":100}'
```

Apify CLI:

```bash
apify call scrapers_lat/remoteok-scraper \
  --input '{"tags":["golang"],"sortBy":"newest","maxJobs":50}'
```

### Fetch results

Every run writes to a dataset. Fetch items as JSON, CSV, or Excel by changing `format`:

```bash
## JSON
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=json"

## CSV
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=csv"

## Paginate large datasets
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&offset=1000&limit=1000"
```

`<DATASET_ID>` is returned as `defaultDatasetId` in the run object. `clean=true` drops empty and internal fields.

### Billing and limits

- **Pay per result.** You are charged per job returned (`result` event). See the [pricing tab](https://apify.com/scrapers_lat/remoteok-scraper/pricing) for the current per-result price.
- **Optional detail add-on.** With `enrichDetails` on, each successfully enriched job also charges a `details` event. It is opt-in, off by default, and disabled for free accounts.
- **No charge on failure.** If a run errors, the actor writes a single item with a populated `error` field and does not charge for it. Empty runs cost nothing.
- **Spend cap respected.** Set `maxTotalChargeUsd` on the run; once reached, the actor stops emitting and charging further results.
- **Free Apify plans** are capped at 10 jobs per run. Upgrade for higher `maxJobs`.
- **Live feed size.** RemoteOK's public feed exposes roughly the 100 most recent postings. The actor filters and sorts across all of them; it does not page deep historical archives.
- **No login or API key** is required.

### FAQ and troubleshooting

**How many jobs can I get per run?**
RemoteOK's public feed serves roughly its 100 most recent postings. This scraper filters and sorts across all of them, so `maxJobs` above ~100 will still return at most what the live feed contains. It is a live feed reader, not a historical archive.

**A run returned 0 records. Why?**
Your filters excluded everything. Loosen `searchTerms`, remove `tags`, `company` or `location`, or turn off `salaryOnly`. Note that `minSalary`, `maxSalary` and `salaryOnly` all drop jobs with no published salary (only a minority of RemoteOK jobs disclose one). Zero-result runs are not charged.

**Why is `salaryMin` / `salaryMax` null on some jobs?**
Not every RemoteOK listing publishes a salary. When none is given, `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryText` are `null` and `salaryDisclosed` is `false`. Use `salaryOnly` to keep only jobs with a published salary.

**How are `category` and `seniority` set?**
Both are derived: `category` from the job title, `seniority` from the tags and title. They are best-effort and return `null` when the title gives no clear signal, so they are never fabricated.

**What does `enrichDetails` add, and why is it optional?**
It fetches each job's RemoteOK page to add `employmentType`, `applicantRegion`, `validThrough` and `companyUrl`. That is one extra request per job, so it is slower and opt-in. It is billed as a `details` event only on a successful fetch and is disabled for free accounts.

**What is the difference between `description` and `rawDescription`?**
`description` is clean plain text (mojibake fixed); `rawDescription` preserves the original HTML (links, lists, formatting).

**Is this an official RemoteOK tool?**
No. This actor is independent and not affiliated with RemoteOK. It reads only publicly available RemoteOK data. Use it in accordance with RemoteOK's terms.

### Related scrapers

- [Remotive Remote Jobs Scraper](https://apify.com/scrapers_lat/remotive-jobs-scraper): remote jobs from Remotive.
- [Reed.co.uk UK Jobs & Salary Scraper](https://apify.com/scrapers_lat/reed-uk-jobs-scraper): UK job listings with salary ranges.
- [Himalayas Remote Jobs Scraper](https://apify.com/scrapers_lat/himalayas-scraper): remote jobs from Himalayas.
- [Greenhouse Jobs Scraper](https://apify.com/scrapers_lat/greenhouse-jobs-scraper): jobs from Greenhouse-hosted career pages.
- [Ashby Jobs Scraper](https://apify.com/scrapers_lat/ashby-jobs-scraper): jobs from Ashby-hosted career pages.

### More scrapers at scrapers.lat

Built and maintained by [scrapers.lat](https://scrapers.lat), where we publish scrapers for US and Latin American public platforms: company registries, government data, finance, e-commerce and more. Browse the catalog or request a custom scraper at [scrapers.lat](https://scrapers.lat).

***

> Independent tool, not affiliated with RemoteOK. Accesses only publicly available RemoteOK data. Use in accordance with RemoteOK's terms.

# Actor input Schema

## `searchTerms` (type: `array`):

Keep a job when its position, company, tags or description matches ANY of these keywords (case-insensitive). Leave empty to keep every job in the feed.

## `excludeTerms` (type: `array`):

Drop a job when its position, company, tags or description matches ANY of these keywords (case-insensitive). Applied after the search keywords.

## `tags` (type: `array`):

Keep only jobs carrying at least one of these RemoteOK tags (case-insensitive), for example engineer, react, golang, marketing, design, senior. Leave empty to ignore tag filtering.

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

Keep only jobs whose company name contains this text (case-insensitive). Leave empty to ignore company filtering.

## `location` (type: `string`):

Keep only jobs whose location text contains this value (case-insensitive), for example Europe, United States or Worldwide. Leave empty to ignore location filtering.

## `remoteRegion` (type: `string`):

Restrict to a hiring region based on the listing's location text. 'worldwide' keeps globally-open roles, 'usa' and 'europe' keep roles pinned to those regions.

## `seniority` (type: `string`):

Keep only jobs at this seniority level, derived from the listing's tags and title.

## `minSalary` (type: `integer`):

Keep only jobs whose published maximum salary is at or above this annual USD amount. Jobs without a published salary are excluded when this is set. Leave empty to ignore.

## `maxSalary` (type: `integer`):

Keep only jobs whose published minimum salary is at or below this annual USD amount. Jobs without a published salary are excluded when this is set. Leave empty to ignore.

## `salaryOnly` (type: `boolean`):

When enabled, keep only listings that publish a salary range.

## `postedAfter` (type: `string`):

Keep only jobs posted on or after this date (YYYY-MM-DD). Leave empty to ignore.

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

Keep only jobs posted within this many days of now. Leave empty to ignore.

## `sortBy` (type: `string`):

Order of the returned jobs. 'newest'/'oldest' sort by posting date; 'salary_high'/'salary_low' sort by published salary (listings without a salary go last).

## `maxJobs` (type: `integer`):

Maximum number of matching jobs to return. RemoteOK's live feed exposes roughly the 100 most recent postings, so this caps how many of those you keep. Optional.

## `enrichDetails` (type: `boolean`):

Fetch each matching job's page to add employmentType, applicantRegion (hiring-region requirement), validThrough (listing expiry) and companyUrl. Slower (one request per job). Billed as a 'details' event only when a page is fetched successfully. Disabled for free accounts.

## `proxyConfiguration` (type: `object`):

Optional proxy. RemoteOK's public feed does not require a proxy; leave empty unless your network needs one.

## Actor input object example

```json
{
  "searchTerms": [
    "engineer"
  ],
  "remoteRegion": "any",
  "seniority": "any",
  "salaryOnly": false,
  "sortBy": "default",
  "maxJobs": 10,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchTerms": [
        "engineer"
    ],
    "maxJobs": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/remoteok-scraper").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 = {
    "searchTerms": ["engineer"],
    "maxJobs": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/remoteok-scraper").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 '{
  "searchTerms": [
    "engineer"
  ],
  "maxJobs": 10
}' |
apify call scrapers_lat/remoteok-scraper --silent --output-dataset

```

## MCP server setup

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

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/INWZ0Ty0algwSI9yJ/builds/QVdEg0ujdwDimseKB/openapi.json
