# Jobicy Remote Jobs Scraper (`logiover/jobicy-remote-jobs-scraper`) Actor

Scrape remote job listings from Jobicy. Filter by keyword, industry, job type, level and geography. Run on a schedule with the posted-since filter to capture only new jobs.

- **URL**: https://apify.com/logiover/jobicy-remote-jobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 💼 Jobicy Remote Jobs Scraper — Scrape Remote Job Listings & Export to JSON/CSV

Scrape remote job listings from **[Jobicy](https://jobicy.com)** — one of the most popular remote-work job boards — straight from its public API. This **Jobicy scraper** delivers a clean, structured feed of remote jobs across development, design, marketing, sales, customer support, data science, finance, HR, writing and more, exported to JSON, CSV or Excel.

Built for **scheduled, recurring use**: run it daily with the `postedSince` filter to capture only newly posted jobs and power an always-fresh remote-jobs pipeline. **No login, no API key, no proxy and no browser needed.**

### ✨ What this Actor does / Key features

- 🌍 Scrape **remote job listings from Jobicy** via its official public API — fast and reliable
- 📋 Rich data per job — title, company, company logo, industries, job type, seniority level, geography, salary range, excerpt, full description and posting date
- 🔎 **Powerful filters** — search keyword, industry, job type, seniority level, geography and posted-since date
- 🔁 **Incremental monitoring** — the `postedSince` filter pulls only jobs posted since your last run
- ⚡ No proxy and no browser required — lightweight and inexpensive to run
- 📌 Set `maxJobs` to `0` to pull every available listing in one run
- 📤 Structured output ready for JSON, CSV and Excel export

### 🔍 Input

All filters are optional — leave them empty to get the latest remote jobs across every industry.

| Field | Type | Description |
|-------|------|-------------|
| `searchKeyword` | string | Free-text keyword matched against job title, company and summary (e.g. `react`, `designer`, `customer support`). |
| `industries` | array | Filter by industry (e.g. `Development`, `Design`, `Marketing`, `Sales`, `Data Science`, `Finance`, `HR`, `Writing`). Empty = all industries. |
| `jobTypes` | array | Filter by job type (e.g. `Full-Time`, `Part-Time`, `Contract`, `Internship`). Empty = all types. |
| `jobLevel` | string | Filter by seniority level (e.g. `Senior`, `Mid`, `Junior`, `Any`). Empty = all levels. |
| `geo` | string | Filter by the role's geography (e.g. `USA`, `Europe`, `Anywhere`). Empty = all locations. |
| `postedSince` | string | ISO date (e.g. `2026-05-13`). Only return jobs posted on or after this date. Set it to the previous run's date for daily incremental monitoring. |
| `maxJobs` | integer | Maximum number of matching jobs to save (Jobicy serves up to 50 most-recent jobs per run). `0` = all. |

### 🚀 Example input

```json
{
  "industries": ["Development"],
  "jobTypes": ["Full-Time"],
  "jobLevel": "Senior",
  "geo": "Anywhere",
  "postedSince": "2026-05-13",
  "maxJobs": 0
}
````

### 📦 Output

Each remote job is saved as one structured record.

| Field | Description |
|-------|-------------|
| `jobId` | Unique Jobicy job ID |
| `title` | Job title |
| `company` | Hiring company name |
| `companyLogo` | URL of the company logo |
| `industries` | Array of industries the job belongs to |
| `jobTypes` | Array of job types (Full-Time, Contract, etc.) |
| `jobLevel` | Seniority level |
| `geo` | Geography / location of the role |
| `annualSalaryMin` | Minimum annual salary |
| `annualSalaryMax` | Maximum annual salary |
| `salaryCurrency` | Currency of the salary range |
| `excerpt` | Short job summary |
| `description` | Full job description |
| `url` | Direct link to the job posting |
| `postedAt` | When the job was posted |
| `scrapedAt` | Scrape timestamp |

#### Sample record

```json
{
  "jobId": "1029384",
  "title": "Senior React Developer",
  "company": "Acme Remote",
  "companyLogo": "https://jobicy.com/.../logo.png",
  "industries": ["Development"],
  "jobTypes": ["Full-Time"],
  "jobLevel": "Senior",
  "geo": "Anywhere",
  "annualSalaryMin": 90000,
  "annualSalaryMax": 130000,
  "salaryCurrency": "USD",
  "excerpt": "We are hiring a Senior React Developer...",
  "url": "https://jobicy.com/jobs/...",
  "postedAt": "2026-05-13",
  "scrapedAt": "2026-05-14T08:00:00.000Z"
}
```

### 💡 Use cases

- **Recruiters & sourcers** — maintain a daily feed of fresh remote roles in your niche.
- **Job boards & aggregators** — keep a remote-jobs section automatically up to date.
- **Market researchers** — track remote hiring trends by industry, seniority level and geography.
- **Lead generation** — identify companies that are actively hiring remote talent.
- **Salary benchmarking** — analyze `annualSalaryMin`/`annualSalaryMax` across industries and levels.

### ❓ Frequently Asked Questions

**Do I need a Jobicy account or API key?**
No. The Actor uses Jobicy's public API — no login and no API key required.

**Is scraping Jobicy legal?**
The Actor collects publicly available job listing data. Use it responsibly and in compliance with Jobicy's terms of service and applicable laws.

**How many jobs can I get per run?**
Jobicy serves up to 50 of the most-recent jobs per run. Set `maxJobs` to `0` to retrieve all available matching jobs.

**How do I capture only new jobs each day?**
Use the `postedSince` filter. Set it to the date of your previous run so the Actor returns only jobs posted on or after that date — perfect for scheduled daily monitoring.

**Can I filter by industry or location?**
Yes. Use `industries`, `jobTypes`, `jobLevel` and `geo` to narrow results, and `searchKeyword` for free-text matching against title, company and summary.

**Do I need a proxy?**
No. The Actor calls Jobicy's API directly without a browser or proxy, which keeps runs fast and cheap.

**What output formats are supported?**
Results are stored in an Apify dataset and can be exported as JSON, CSV, Excel, XML or HTML, or pulled via the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to run daily with a rolling `postedSince` date for a continuously updated remote-jobs dataset with zero manual work. Export results to JSON, CSV or Excel, call it via the Apify API, or connect it to Google Sheets, Slack and webhooks through Apify integrations.

# Actor input Schema

## `searchKeyword` (type: `string`):

Free-text keyword matched against job title, company and summary. Examples: 'react', 'designer', 'customer support'.

## `industries` (type: `array`):

Filter by industry. Examples: 'Development', 'Design', 'Marketing', 'Sales', 'Customer Success', 'Data Science', 'Finance', 'HR', 'Writing'. Leave empty for all industries.

## `jobTypes` (type: `array`):

Filter by job type. Examples: 'Full-Time', 'Part-Time', 'Contract', 'Internship'. Leave empty for all types.

## `jobLevel` (type: `string`):

Filter by seniority level, e.g. 'Senior', 'Mid', 'Junior', 'Any'. Leave empty for all levels.

## `geo` (type: `string`):

Filter by the role's geography, e.g. 'USA', 'Europe', 'Anywhere'. Leave empty for all locations.

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

ISO date (e.g. 2026-05-13). Only return jobs posted on or after this date. Set this to the previous run's date to capture only new jobs — ideal for scheduled daily monitoring.

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

Maximum number of matching jobs to save (Jobicy serves up to 50 most-recent jobs per run). 0 = all.

## Actor input object example

```json
{
  "searchKeyword": "",
  "industries": [],
  "jobTypes": [],
  "jobLevel": "",
  "geo": "",
  "postedSince": ""
}
```

# Actor output Schema

## `title` (type: `string`):

Job title

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

Hiring company

## `industries` (type: `string`):

Job industries

## `jobTypes` (type: `string`):

Full-Time / Part-Time / …

## `jobLevel` (type: `string`):

Seniority level

## `geo` (type: `string`):

Role geography

## `excerpt` (type: `string`):

Short job summary

## `url` (type: `string`):

Job listing URL

## `postedAt` (type: `string`):

Publication date

## `scrapedAt` (type: `string`):

Scrape timestamp

# 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 = {
    "industries": [],
    "jobTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/jobicy-remote-jobs-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 = {
    "industries": [],
    "jobTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/jobicy-remote-jobs-scraper").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 '{
  "industries": [],
  "jobTypes": []
}' |
apify call logiover/jobicy-remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobicy Remote Jobs Scraper",
        "description": "Scrape remote job listings from Jobicy. Filter by keyword, industry, job type, level and geography. Run on a schedule with the posted-since filter to capture only new jobs.",
        "version": "0.0",
        "x-build-id": "9270pUurkHAgwcNWp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~jobicy-remote-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-jobicy-remote-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~jobicy-remote-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-jobicy-remote-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~jobicy-remote-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-jobicy-remote-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchKeyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Free-text keyword matched against job title, company and summary. Examples: 'react', 'designer', 'customer support'.",
                        "default": ""
                    },
                    "industries": {
                        "title": "Industries",
                        "type": "array",
                        "description": "Filter by industry. Examples: 'Development', 'Design', 'Marketing', 'Sales', 'Customer Success', 'Data Science', 'Finance', 'HR', 'Writing'. Leave empty for all industries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTypes": {
                        "title": "Job Types",
                        "type": "array",
                        "description": "Filter by job type. Examples: 'Full-Time', 'Part-Time', 'Contract', 'Internship'. Leave empty for all types.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobLevel": {
                        "title": "Job Level",
                        "type": "string",
                        "description": "Filter by seniority level, e.g. 'Senior', 'Mid', 'Junior', 'Any'. Leave empty for all levels.",
                        "default": ""
                    },
                    "geo": {
                        "title": "Geography",
                        "type": "string",
                        "description": "Filter by the role's geography, e.g. 'USA', 'Europe', 'Anywhere'. Leave empty for all locations.",
                        "default": ""
                    },
                    "postedSince": {
                        "title": "Posted Since (optional)",
                        "type": "string",
                        "description": "ISO date (e.g. 2026-05-13). Only return jobs posted on or after this date. Set this to the previous run's date to capture only new jobs — ideal for scheduled daily monitoring.",
                        "default": ""
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of matching jobs to save (Jobicy serves up to 50 most-recent jobs per run). 0 = all."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```