# LinkedIn Remote Jobs 🌍 (clean feed, no login) (`tagadanar/linkedin-remote-jobs`) Actor

Remote-only LinkedIn job postings by keyword and region, in clean JSON. Every result is pre-filtered to remote work, no toggle to forget. Hiring company, location, posting date and optional full description. One all-in price per job, no API key, no login.

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

## Pricing

from $1.40 / 1,000 job scrapeds

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?

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

## LinkedIn Remote Jobs

A clean feed of remote-only job postings from LinkedIn. Give it a keyword and, if you want, a country or region, and get back a flat table of remote roles: job title, hiring company, location, posting date, and a direct link. There is no "remote" toggle to remember, because every result already is one: the actor pins LinkedIn's own work-arrangement filter (`f_WT=2`) on every search, so a broad keyword never leaks in-office or hybrid postings.

No login. No cookies to paste. No API key. One clear price per job, with platform usage already included.

This actor scrapes public job postings and the hiring company only. It does not collect personal profiles, applicants, or the person who posted the job.

### What you get

One record per remote job posting:

| Field | Description |
| --- | --- |
| `jobId` | LinkedIn job posting ID |
| `title` | Job title |
| `jobUrl` | Direct link to the public job posting |
| `companyName` | Hiring company |
| `companyUrl` | The company's LinkedIn page |
| `companySlug` | Company handle from its URL (handy for joins and enrichment) |
| `companyLogoUrl` | Company logo image |
| `location` | Location as shown on the posting (often the hiring entity's base, even though the role is remote) |
| `workType` | Always `"remote"` — a constant, since every search on this actor is remote-only |
| `postedAt` | Posting age in the site's own words (e.g. "2 days ago") |
| `postedDate` | Posting date as ISO `YYYY-MM-DD` |
| `isNew` | Flagged as newly posted by LinkedIn |
| `benefits` | Any badge on the card (e.g. "Actively Hiring") |
| `searchKeyword` | The keyword this row came from |
| `searchLocation` | The location filter this row came from, if any |
| `source` | `linkedin.com` |
| `scrapedAt` | When the row was collected (ISO) |

With **Add full job description** switched on, every row also gets:

| Field | Description |
| --- | --- |
| `description` | Full job description text |
| `descriptionHtml` | The same description with its original formatting |
| `seniorityLevel` | e.g. Entry level, Mid-Senior level, Director |
| `employmentType` | Full-time, Part-time, Contract, and so on |
| `jobFunction` | The job function LinkedIn assigns |
| `industries` | The hiring company's industry |
| `applicantsCount` | How many people have applied so far |
| `applicantsCaption` | Applicant count in the site's own words |

Descriptions are billed as a small extra, and only when the extra data is actually found. A posting that has no details to return costs you nothing beyond the base job.

### Who uses this

- **Job boards and aggregators:** keep a fresh mirror of remote-only postings for a niche or a set of keywords, refreshed on a schedule, without a manual remote filter to maintain downstream.
- **Job seekers:** search a role once, get only jobs you can actually do from home, with the description and applicant count already attached.
- **Remote-first communities and newsletters:** curate a weekly list of new remote openings by keyword.
- **Recruiters placing remote candidates:** watch a role for remote-only openings across companies, without sifting hybrid and on-site results out by hand.

### Input examples

Copy any of these into the input, or use the visual form.

**A single search, worldwide remote:**

```json
{
  "keywords": ["software engineer"],
  "maxItems": 100
}
```

**Remote jobs based in a region, with full descriptions:**

```json
{
  "keywords": ["customer support"],
  "location": "Europe",
  "withDescription": true,
  "maxItems": 100
}
```

**New remote postings from the last 24 hours, run it daily as a monitor:**

```json
{
  "keywords": ["product manager", "product designer"],
  "postedSince": "24h",
  "maxItems": 200
}
```

### Output sample

```json
{
  "jobId": "4447220072",
  "title": "Software Engineer (All Levels)",
  "jobUrl": "https://www.linkedin.com/jobs/view/4447220072",
  "companyName": "Blossom",
  "companyUrl": "https://www.linkedin.com/company/join-blossom-health",
  "companySlug": "join-blossom-health",
  "companyLogoUrl": "https://media.licdn.com/dms/image/v2/D4E0BAQHmZIXWaQE7vA/company-logo_100_100/...",
  "location": "New York, NY",
  "workType": "remote",
  "postedAt": "2 weeks ago",
  "postedDate": "2026-07-30",
  "isNew": false,
  "benefits": null,
  "searchKeyword": "software engineer",
  "searchLocation": null,
  "source": "linkedin.com",
  "scrapedAt": "2026-08-20T09:00:00.000Z"
}
```

### Pricing

You pay per remote job returned, and a small extra only for jobs where full-description enrichment actually found data. Platform usage is included in the price, so there is no subscription.

| Event | Price |
| --- | --- |
| Actor start | $0.001 per run |
| Job scraped | $2.00 per 1,000 |
| Job details | $2.00 per 1,000 (only with **Add full job description**, and only when the extra data was found) |

The tiny start fee covers runs that return nothing; on any normal search it is noise next to the per-job price.

### FAQ

**Do I need a LinkedIn account or a cookie?**
No. This reads LinkedIn's public jobs pages, so there is no login, no session cookie and no API key to manage.

**Does it ever return hybrid or on-site jobs?**
No. Every search is filtered server-side to LinkedIn's own "Remote" work-arrangement facet before results come back, so there is nothing to accidentally leave unchecked.

**Does it scrape people or applicants?**
No. It collects the public job posting and the hiring company only. It never collects personal profiles, the names of applicants, or the person who posted the role.

**Why does `location` sometimes show a city if the job is remote?**
That is LinkedIn's own posting data: many companies list their base city even for a fully remote role. Use the **Location** input to narrow which country or region the listing is anchored to.

**How do I only get brand-new remote jobs?**
Set **Posted since** to the last 24 hours (or last week) and schedule the run. Each run returns only what LinkedIn currently shows in that window, so a daily 24-hour run is a simple new-remote-jobs monitor.

**Can I get the full job description and how many people applied?**
Yes. Switch on **Add full job description**. Each job then includes the full description, seniority, employment type, job function, industry and the live applicant count. This opens each posting individually, so it is a little slower and costs a small extra per enriched job.

**How many jobs can I get per search?**
LinkedIn serves a few hundred remote results per individual keyword before it stops paginating. To go deeper, split a broad keyword into several narrower ones and the actor will run them all and de-duplicate the results.

**Is the data structured?**
Yes. Every run produces one flat JSON or CSV row per job with the same fields, ready for a spreadsheet, a CRM import or a database.

### Related actors

- [LinkedIn Jobs Scraper](https://apify.com/tagadanar/linkedin-jobs-scraper): the full LinkedIn jobs search, with on-site/hybrid/remote, experience level, job type and company filters.

***

LinkedIn remote jobs, remote jobs scraper, LinkedIn work from home jobs, remote job listings, LinkedIn remote jobs API, work from home jobs dataset, remote jobs feed, remote hiring companies, remote jobs by keyword, remote jobs monitor, new remote jobs alert, LinkedIn remote jobs alternative, remote job postings export.

# Actor input Schema

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

One search per entry, exactly what you would type into the LinkedIn jobs search box, e.g. <code>software engineer</code>, <code>customer support</code>, <code>copywriter</code>. Every search is already filtered to remote jobs only.

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

Narrow remote jobs to a country or region, e.g. <code>United States</code>, <code>Europe</code>, <code>France</code>. Leave empty to search remote jobs worldwide.

## `geoId` (type: `string`):

LinkedIn's own numeric location ID, if you already have one from a LinkedIn search URL. Takes priority over free-text matching when both are set.

## `postedSince` (type: `string`):

Only jobs posted recently. Handy for running this as a scheduled monitor: set it to the last 24 hours and re-run daily to catch new remote postings.

## `withDescription` (type: `boolean`):

Open each posting to also collect the full job description, seniority level, employment type, job function, industries and the applicant count. Slower and billed as a small extra per enriched job. Leave off for a fast title + company + link list.

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

Stop after this many remote jobs across all keywords. You are only charged for jobs actually delivered.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "postedSince": "any",
  "withDescription": false,
  "maxItems": 10
}
```

# Actor output Schema

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

One item per remote job in the default dataset.

# 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 = {
    "keywords": [
        "software engineer"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/linkedin-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 = {
    "keywords": ["software engineer"],
    "maxItems": 10,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tagadanar/linkedin-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/S1Q4CEbylpnh7gJ2k/builds/5hFrpmNZxGVHEU46F/openapi.json