# Remote Jobs for International Candidates — AI-Powered Filter (`rjm8pro/remote-jobs-international`) Actor

Scrapes Arbeitnow, RemoteOK, Himalayas, LinkedIn & Indeed. Uses AI to detect if each company hires outside the USA. Returns international\_eligible: true/false for each job.

- **URL**: https://apify.com/rjm8pro/remote-jobs-international.md
- **Developed by:** [Reinaldo Martinez](https://apify.com/rjm8pro) (community)
- **Categories:** Jobs, AI, Automation
- **Stats:** 4 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Remote Jobs International — Apify Actor

Scrapes **Arbeitnow, RemoteOK, Himalayas, LinkedIn, and Indeed** for remote jobs and uses Claude AI to detect whether each company hires candidates living **outside the USA**.

The key output field — `international_eligible: true/false` — is unique: no other job scraper on Apify has this today.

***

### Quick Start

#### 1. Install Apify CLI and log in

```bash
npm install -g apify-cli
apify login   # opens browser to authenticate
```

#### 2. Clone and install dependencies

```bash
cd remote-jobs-actor
npm install
```

#### 3. Set environment variables for local testing

```bash
## Create a .env file (never commit this)
echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
echo "APIFY_TOKEN=apify_api_..." >> .env
```

#### 4. Run locally

```bash
apify run
```

The actor reads input from `./storage/key_value_stores/default/INPUT.json`.\
Create it with your test input:

```json
{
  "keywords": "react developer",
  "sources": ["arbeitnow", "remoteok", "himalayas"],
  "maxJobsPerSource": 20,
  "candidateCountry": "Mexico",
  "filterInternationalOnly": false,
  "useAiFilter": true
}
```

#### 5. Deploy to Apify

```bash
apify push
```

***

### Output Schema

Each item in the dataset looks like this:

```json
{
  "title": "Senior React Developer",
  "company": "Acme Corp",
  "location": "Remote",
  "url": "https://...",
  "source": "arbeitnow",
  "posted_at": "2025-06-06T00:00:00Z",
  "salary": "$90k–$130k",
  "tags": ["react", "typescript", "remote"],

  "international_eligible": true,
  "international_signals": ["contractor", "deel"],
  "international_confidence": "high",
  "international_reason": "Job mentions Deel for payments and accepts contractors worldwide.",
  "detection_method": "ai",

  "scraped_at": "2025-06-06T20:00:00Z",
  "candidate_country": "Mexico"
}
```

#### `international_eligible` values

| Value | Meaning |
|-------|---------|
| `true` | Company likely hires internationally |
| `false` | Explicit US-only restrictions found |
| `null` | Could not determine (AI not enabled or no signals found) |

***

### Monetization (Pay Per Event)

This Actor is designed for **PPE (Pay Per Event)** pricing on the Apify Store.

**Recommended price:** `$0.005` per saved job result (~$5 per 1,000 jobs).

To configure PPE:

1. Go to **Apify Console → My Actors → \[this actor] → Publication → Monetization**
2. Select **Pay Per Event**
3. Define event: `job_saved` — triggered by each `Actor.pushData()` call
4. Set price per event: `$0.005`

***

### Environment Variables

Set these in **Apify Console → Actor → Environment Variables**:

| Variable | Required | Description |
|----------|----------|-------------|
| `ANTHROPIC_API_KEY` | For AI filter | Your Anthropic API key |
| `APIFY_TOKEN` | For LinkedIn/Indeed | Your Apify API token (auto-available on platform) |

***

### Cost Estimate (per run)

| Source | Cost per 100 results |
|--------|---------------------|
| Arbeitnow | Free |
| RemoteOK | Free |
| Himalayas | Free |
| LinkedIn | ~$0.20 (via curious\_coder actor) |
| Indeed | ~$0.01 (via valig actor) |
| Claude AI filter (per job) | ~$0.0002 (Haiku model) |

For 200 jobs from free sources with AI filter: **~$0.04 total cost**.

***

### Project Structure

```
remote-jobs-actor/
├── .actor/
│   ├── actor.json          # Actor metadata
│   ├── input_schema.json   # Input UI schema for Apify Console
│   └── Dockerfile
├── src/
│   ├── main.js             # Entry point — orchestrates everything
│   ├── aiFilter.js         # THE DIFFERENTIATOR — international eligibility AI
│   └── scrapers/
│       ├── freeApis.js     # Arbeitnow + RemoteOK + Himalayas
│       ├── linkedin.js     # Via existing Apify actor
│       └── indeed.js       # Via existing Apify actor
├── package.json
└── README.md
```

# Actor input Schema

## `keywords` (type: `string`):

Role or skills to search for. E.g. 'software engineer', 'react developer', 'data analyst'

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

Which platforms to search. Select one or more.

## `maxJobsPerSource` (type: `integer`):

Maximum number of job listings to fetch per platform.

## `candidateCountry` (type: `string`):

Your country of residence. Used to filter for international-friendly roles.

## `filterInternationalOnly` (type: `boolean`):

If true, only return jobs where the company likely hires internationally.

## `useAiFilter` (type: `boolean`):

Uses Claude AI to analyze each job description and determine if international candidates are accepted. Requires ANTHROPIC\_API\_KEY in environment.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "sources": [
    "arbeitnow",
    "remoteok",
    "himalayas"
  ],
  "maxJobsPerSource": 50,
  "candidateCountry": "Mexico",
  "filterInternationalOnly": false,
  "useAiFilter": true
}
```

# 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("rjm8pro/remote-jobs-international").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("rjm8pro/remote-jobs-international").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 '{}' |
apify call rjm8pro/remote-jobs-international --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/wopELRCPAbIqeVsT8/builds/tWyVmIK76gzfdB0Au/openapi.json