# Jobgether Remote Jobs Scraper (`automation-lab/jobgether-remote-jobs-scraper`) Actor

Find and export public Jobgether remote jobs with company, location, posting date, employment type, full description, requirements, responsibilities, skills, and source links.

- **URL**: https://apify.com/automation-lab/jobgether-remote-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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

## Jobgether Remote Jobs Scraper

Export public remote job listings from Jobgether into a clean, analysis-ready dataset.
Search by keyword, use a Jobgether category or location URL, or extract one exact offer.
Get job titles, companies, posting dates, remote locations, employment types, descriptions, qualifications, responsibilities, skills, and canonical links.

The Actor uses lightweight HTTP extraction rather than a browser.
No Jobgether login or private API key is required.
Results can be downloaded as JSON, CSV, Excel, XML, or RSS and connected to the Apify API, webhooks, schedules, and MCP.

### What does Jobgether Remote Jobs Scraper do?

Jobgether Remote Jobs Scraper turns Jobgether's public remote-job pages into structured records.
It supports both discovery and exact-URL workflows:

- 🔎 Search Jobgether jobs by keyword.
- 🔗 Scrape Jobgether search, category, location, or offer URLs.
- 🌍 Filter by remote country or region.
- 💼 Filter by employment type or role text.
- 🗓️ Keep only jobs posted within a selected number of days.
- 📄 Fetch complete public job descriptions and enriched role facts.
- 🧠 Extract qualifications, responsibilities, hard skills, and other skills.
- ⚡ Skip detail pages when only a fast listing feed is needed.

Each successful item represents one Jobgether offer.
Canonical URLs and offer IDs make repeated-run deduplication straightforward.

### Who is it for?

#### Job aggregators and niche job boards

Refresh remote inventory daily, normalize records, and deduplicate them by `offerId` or `canonicalUrl`.
Use detail mode when your product needs complete descriptions and skills.

#### Recruiters and talent sourcers

Find companies hiring for a role, country, or skill.
Send new records to a CRM, spreadsheet, ATS, or sourcing queue.

#### Job-alert product teams

Schedule narrow keyword searches and notify users only about newly seen offer IDs.
The `postedAt` field supports freshness rules.

#### Labor-market analysts

Track remote hiring volume, geography, employment types, role tags, and skill demand over time.
Store daily datasets in a warehouse for longitudinal analysis.

#### Developers and AI-agent builders

Call the Actor through REST, JavaScript, Python, cURL, or MCP.
Return structured evidence to an application instead of asking an agent to browse pages manually.

### Why use this remote jobs extractor?

- ✅ **Source-specific data** — fields are designed around Jobgether offers, not generic page text.
- ✅ **Useful detail records** — descriptions, qualifications, responsibilities, and skills are available when exposed publicly.
- ✅ **Low compute** — direct HTML and Schema.org data keep runs lightweight.
- ✅ **Strict scope** — non-Jobgether start URLs are rejected instead of silently scraping unrelated pages.
- ✅ **Fail-closed filters** — records without the requested date or filter evidence are excluded.
- ✅ **Automation-ready IDs** — stable offer IDs simplify alerts and database upserts.
- ✅ **Standard exports** — use JSON, CSV, Excel, XML, RSS, or the dataset API.

### What Jobgether data can you extract?

| Field | Type | Meaning |
|---|---|---|
| `offerId` | string | Stable ID parsed from the Jobgether offer URL |
| `title` | string | Public job title |
| `company` | string | Hiring organization |
| `companyUrl` | string | Public company website when supplied |
| `companyLogoUrl` | string | Public company logo URL |
| `postedAt` | string | ISO 8601 posting timestamp |
| `locations` | array | Applicant countries or remote regions |
| `remoteScope` | string | Remote-work classification |
| `employmentTypes` | array | Full-time, contract, part-time, or other source values |
| `roleTags` | array | Jobgether role/category labels |
| `language` | string | Role language when displayed |
| `qualifications` | array | Structured qualification bullets |
| `responsibilities` | array | Structured responsibility bullets |
| `hardSkills` | array | Jobgether hard-skill tags |
| `softSkills` | array | Other skill labels |
| `description` | string | Clean full public description |
| `canonicalUrl` | string | Canonical Jobgether offer URL |
| `applyUrl` | string | Public apply link when exposed without login |
| `scrapedAt` | string | ISO 8601 extraction time |

Optional fields are omitted when the source does not expose them.
Array fields stay arrays in JSON exports.

### How to scrape Jobgether remote jobs

1. Open the Actor input page.
2. Enter a keyword such as `software engineer`, or add Jobgether URLs.
3. Optionally set category, location, employment type, or recency filters.
4. Keep **Include full job details** enabled for rich records.
5. Choose a small `maxItems` for a first run.
6. Click **Start**.
7. Review the Dataset tab and export or integrate the records.

For recurring monitoring, save the task and attach an Apify schedule.
Compare `offerId` values with the previous run before sending alerts.

### Input parameters

| Input | Type | Default | Description |
|---|---|---:|---|
| `keyword` | string | `software engineer` prefill | Search title, company, and role labels |
| `startUrls` | array | empty | Jobgether search, category, location, or offer URLs |
| `category` | string | empty | Required text in role title or tags |
| `location` | string | empty | Required text in remote location |
| `employmentType` | string | empty | Required employment-type text |
| `recencyDays` | integer | empty | Maximum age in days |
| `includeDetails` | boolean | `true` | Fetch every selected offer page |
| `maxItems` | integer | `10` | Maximum saved jobs, up to 1,000 |
| `proxyConfiguration` | object | direct | Optional Apify/custom proxy settings |

When `startUrls` is supplied, it overrides generated keyword discovery.
A keyword still acts as a strict local filter if both are supplied.

### Input examples

#### Keyword search with full details

```json
{
  "keyword": "data engineer",
  "includeDetails": true,
  "maxItems": 20
}
```

#### Country page with freshness filter

```json
{
  "startUrls": [{ "url": "https://jobgether.com/remote-jobs/united-states" }],
  "recencyDays": 7,
  "includeDetails": true,
  "maxItems": 25
}
```

#### Fast listing-only feed

```json
{
  "keyword": "sales",
  "includeDetails": false,
  "maxItems": 50
}
```

### Output example

```json
{
  "offerId": "6a4e26bcac00a71a5a8101cb",
  "title": "Channel Development Manager, Lenovo",
  "company": "Absolute Software",
  "postedAt": "2026-07-08T10:30:20.000Z",
  "locations": ["US"],
  "remoteScope": "Remote",
  "employmentTypes": ["FULL_TIME"],
  "roleTags": ["Channel Development Manager"],
  "hardSkills": ["Customer Engagement", "Sales Planning", "Project Management"],
  "softSkills": ["Communication", "Decision Making", "Teamwork"],
  "canonicalUrl": "https://jobgether.com/offer/6a4e26bcac00a71a5a8101cb-channel-development-manager-lenovo",
  "scrapedAt": "2026-07-16T03:00:00.000Z"
}
```

The exact public inventory changes frequently.
Example values illustrate the schema rather than guaranteeing that an offer remains active.

### How much does it cost to scrape Jobgether jobs?

This Actor uses pay-per-event pricing:

- A small one-time Actor start charge covers run setup.
- A job-extracted event is charged only for records saved to the dataset.
- Account tiers receive the prices displayed in the Apify Console before a run starts.

The current source package starts at **$0.005 per run** plus **$0.000072217 per job on the BRONZE tier**. Other account tiers use the prices displayed by Apify before the run starts.
Final account-specific pricing is always shown by Apify.
A five-job smoke test is intentionally inexpensive.
Detail mode makes more requests but does not create shell or error items.

### Listing mode versus detail mode

Set `includeDetails` to `false` for a fast feed containing card-level fields such as title, company, location, employment type, role tags, logo, and URL.

Keep `includeDetails` at `true` to add:

- 📅 Posting timestamps
- 🏢 Company links
- 📄 Full descriptions
- 🎓 Qualifications
- 🧭 Responsibilities
- 🛠️ Hard skills
- 🤝 Other skills

A `recencyDays` filter requires posting dates, so the Actor reads detail pages even if detail mode is disabled.

### Filtering behavior

Filters are case-insensitive text matches.
They are intentionally strict:

- A location filter excludes jobs without a matching location.
- An employment filter excludes jobs without a matching source value.
- A category filter checks role tags and titles.
- A recency filter excludes jobs without a parseable posting timestamp.
- A total extraction failure makes the run fail rather than return a misleading empty success.

If a narrow combination returns no jobs, remove one filter and try again.

### Scheduling a remote job monitor

1. Save a task with a focused keyword and `recencyDays`.
2. Add a daily or hourly schedule in Apify Console.
3. Send the completed dataset to a webhook or automation platform.
4. Upsert records using `offerId` as the key.
5. Notify only when an ID has not appeared before.

For market analysis, retain dated datasets instead of deduplicating them.
That produces a historical snapshot series.

### Integrations

#### Google Sheets and Excel

Export CSV/XLSX manually or use Make to append newly discovered offers to a hiring tracker.

#### Slack and email alerts

Attach a run-success webhook, compare IDs in your automation, and send only unseen matching jobs.

#### Airtable, Notion, and databases

Map `offerId` to a unique key and update changing descriptions or dates without creating duplicates.

#### Data warehouses

Load JSON records into BigQuery, Snowflake, or PostgreSQL for geography and skill-trend analysis.

#### AI recruiting agents

Provide structured qualifications and responsibilities to a ranking workflow.
Keep human review in the loop for employment decisions.

### API usage

Run the Actor programmatically with your Apify API token, then read records from its default dataset. The examples below cover JavaScript, Python, and cURL.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jobgether-remote-jobs-scraper').call({
  keyword: 'cybersecurity',
  includeDetails: true,
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/jobgether-remote-jobs-scraper').call(run_input={
    'keyword': 'product manager',
    'includeDetails': True,
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~jobgether-remote-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"python","includeDetails":true,"maxItems":10}'
```

Fetch the dataset using the `defaultDatasetId` from the completed run.
Do not place long-lived tokens in source control.

### Use Jobgether Remote Jobs Scraper with MCP

Connect Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/jobgether-remote-jobs-scraper"
```

Claude Desktop, Cursor, and VS Code can use this JSON configuration:

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

Example prompts:

- “Find ten recent remote data engineering jobs on Jobgether and summarize required skills.”
- “Extract this Jobgether offer and compare its responsibilities with my role rubric.”
- “Create a table of remote cybersecurity roles by company and location.”

### Performance and reliability tips

- 🚀 Use listing mode for broad discovery and detail mode only when rich fields matter.
- 🎯 Start with one filter, then narrow it after confirming source terminology.
- 🔢 Keep scheduled runs bounded with `maxItems`.
- 🌐 Leave proxy settings empty unless direct access is restricted in your environment.
- 🧩 Store `offerId` rather than title alone for deduplication.
- 📆 Use `recencyDays` for alerts, not for long-term historical backfills.

The Actor batches detail requests conservatively to reduce pressure on the source.
Transient failure of an optional detail page preserves its listing fields unless a requested filter depends on detail data.

### Limitations

- Jobgether can change HTML structure, labels, inventory, or public access.
- Search pages expose a bounded current result set; the Actor does not claim to mirror all advertised jobs in one run.
- Match scores and features requiring a Jobgether account are excluded.
- An external apply URL is returned only when it is public in the fetched page.
- Some offers omit language, company website, or structured skill sections.
- Source labels can differ across employers.

### Is scraping Jobgether legal?

This Actor extracts publicly accessible job information.
Scraping legality depends on jurisdiction, purpose, contractual terms, and how results are used.

Use the Actor responsibly:

- Review Jobgether's current terms and robots guidance.
- Avoid excessive request rates.
- Do not collect restricted account-only data.
- Respect privacy, employment, anti-discrimination, and database-rights rules.
- Keep a lawful basis for storing or redistributing records.
- Do not use scraped attributes to make unlawful automated employment decisions.

This section is general information, not legal advice.

### FAQ

#### Does this Jobgether scraper require login?

No. Version 0.1 targets public search, category, location, and offer pages.
Login-only match scoring is not included.

#### Can I scrape one exact Jobgether offer?

Yes. Put its `/offer/...` URL in `startUrls`.
The Actor validates that it belongs to Jobgether.

#### Why did my filtered run return no records?

The filter combination may be narrower than the current source inventory or may use different terminology.
Try removing location, category, or employment type one at a time.

#### Why is a field missing?

Optional values are omitted when Jobgether does not expose them publicly for that offer.
Enable detail mode for the richest record.

#### Can I run it every day?

Yes. Use an Apify task and schedule, then deduplicate by `offerId`.
Small focused runs are best for alerts.

#### Does it support proxies?

Yes. Configure Apify Proxy or custom proxies through `proxyConfiguration`.
Direct access is the default because it avoids unnecessary proxy cost.

#### What happens if Jobgether returns an error page?

The Actor fails on invalid responses or total extraction failure rather than reporting an empty successful run.
Check the run log and retry after confirming the source is available.

### Related job scrapers

Combine this source with other automation-lab job datasets when your workflow needs broader coverage:

- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)
- [Dice.com Tech Jobs Scraper](https://apify.com/automation-lab/dice-jobs-scraper)
- [Indeed Jobs Scraper](https://apify.com/automation-lab/indeed-jobs-scraper)

Use source-specific IDs separately; IDs from different job boards are not interchangeable.

### Support

If a Jobgether page no longer parses, open an issue from the Actor page.
Include the run URL, sanitized input, expected record, and observed output.
Do not include API tokens, personal credentials, or confidential candidate data.

# Actor input Schema

## `keyword` (type: `string`):

Search job titles, companies, and role tags, for example Python, data engineer, or cybersecurity.

## `startUrls` (type: `array`):

Optional Jobgether search, category, location, or individual offer URLs. These override the generated keyword search.

## `category` (type: `string`):

Keep jobs whose title or Jobgether role tag contains this text.

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

Keep jobs whose remote location contains this country or region, such as United States or Europe.

## `employmentType` (type: `string`):

Keep matching employment types such as FULL\_TIME, Full time, Contract, or Part time.

## `recencyDays` (type: `integer`):

Only return jobs posted within this many days. Leave empty for any posting date.

## `includeDetails` (type: `boolean`):

Fetch each offer page for posting date, description, skills, qualifications, responsibilities, and company data.

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

Maximum number of job records saved to the dataset.

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

Optional Apify Proxy or custom proxy settings. Direct access is used when left empty.

## Actor input object example

```json
{
  "keyword": "software engineer",
  "includeDetails": true,
  "maxItems": 5
}
```

# Actor output Schema

## `overview` (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 = {
    "keyword": "software engineer",
    "includeDetails": true,
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jobgether-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 = {
    "keyword": "software engineer",
    "includeDetails": True,
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jobgether-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 '{
  "keyword": "software engineer",
  "includeDetails": true,
  "maxItems": 5
}' |
apify call automation-lab/jobgether-remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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