# Jobgether Scraper – Remote Jobs API with Salary & Apply Link (`data_daemon/jobgether-jobs-scraper`) Actor

Scrape Jobgether remote jobs by keyword, skill, country or region, employment type, seniority, salary and date. Each job has the company, where it is open, salary, skills, posting time and the employer's apply link; full description on request. Only-new mode for daily feeds. No login, no proxy.

- **URL**: https://apify.com/data_daemon/jobgether-jobs-scraper.md
- **Developed by:** [Daemon Data](https://apify.com/data_daemon) (community)
- **Categories:** Jobs, Lead generation, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 jobs

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

**Jobgether Jobs Scraper** returns **remote jobs from [Jobgether](https://jobgether.com)** (173,013 live jobs on 17 November 2026) as JSON, CSV or Excel: title, company with website and size, the **countries and regions the job is open to**, employment type, seniority, **salary range**, skills, posting time and the **employer's own apply link** (Workday, Lever, Greenhouse, Ashby and other applicant tracking systems). Search by keyword, skill, country or region, company, employment type, experience level, salary and date; add the full description and requirements on request; an **only-new mode** turns any search into a feed that delivers each job once. **$0.80 per 1,000 jobs**, no login, no proxy, no API key from Jobgether.

It is for job boards and aggregators that need a remote-jobs feed, recruiters and sourcing teams tracking who hires remotely, sales teams using hiring as a buying signal, salary and labour-market analysts, and AI agents that answer "which remote jobs can I apply to from my country".

| You are building | Input | Jobs (measured 17 Nov 2026) | Run time | Cost |
|---|---|---|---|---|
| A sample of the **newest remote jobs** | `{}` | 50 | 2-3 s | $0.04 |
| A **keyword search** | `keywords: ["data engineer"]`, `maxResults: 200` | 200 of 2,500 listed | 10 s | $0.16 |
| **Remote jobs open to one country** | `keywords: ["python"]`, `locations: ["Germany"]`, `maxResults: 0` | 128 (all listed) | 7 s | $0.10 |
| A **bulk pull** of the newest jobs | `maxResults: 1000` | 1,000 | 63 s | $0.80 |
| **Company watchlist** | `companies: ["GitLab", "ConcertoCare"]`, `maxResults: 0` | 229 (226 + 3) | 15 s | $0.18 |
| A **daily internship and freelance feed** | `employmentTypes`, `postedWithinDays: 1`, `onlyNewSinceLastRun` | 135 on the first run, 0 on the second | 9 s | $0.11, then $0.001 |
| Jobs **with full description and requirements** | `includeDescription`, `includeRequirements`, `maxResults: 20` | 20 | 47 s | $0.02 |

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~jobgether-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"keywords": ["python"], "locations": ["Germany"], "postedWithinDays": 7, "maxResults": 100}'
```

### What can you do with Jobgether job data?

- **Remote job boards and newsletters:** a feed of new remote jobs by role, skill or country, each with the employer's apply link, so readers land on the company's own application page.
- **Recruiters and staffing firms:** which companies hire remotely for which roles, at which seniority, and where candidates may live.
- **Sales and lead generation:** a company that posts ten remote roles is growing; rows carry the company website and size band.
- **Salary research:** yearly salary ranges with currency, by role, seniority and country (shown on 46% of the 1,000 newest jobs on 17 November 2026).
- **AI agents and career tools:** structured jobs through the Apify API or the Apify MCP server, filtered to the user's country.

### How to scrape Jobgether jobs

1. Open the **Input** tab. Add `keywords` (`python`, `data engineer`), and optionally `locations` (`Germany`, `Europe`, `United States`, `Worldwide`).
2. Narrow with employment type, experience level, skills, companies, minimum salary or posting date if you need to.
3. Click **Start**. Jobs appear in the **Output** tab; download them as JSON, CSV, Excel or HTML, or read them through the API.
4. For a feed, turn on **Only new jobs since the last run**, save the input as a task and add a schedule.

An empty input `{}` returns the 50 newest jobs on Jobgether.

### Input

| Field | What it does |
|---|---|
| `keywords` | Job titles or words, one search each, through Jobgether's own keyword search. Empty = all jobs. Also accepted: `query`, `queries`, `search`, `q`. |
| `locations` | Where the candidate lives: a country, a region (`Europe`, `EMEA`, `Latin America`, `APAC`), a US state or `Worldwide`. One search per entry. Jobgether returns the jobs open to people there, which includes jobs open to the whole region and to anyone. Names are looked up in Jobgether's location list; an unknown name is skipped and named in the status message. |
| `employmentTypes` | `full_time`, `part_time`, `fixed_term`, `freelance`, `internship`. |
| `experienceLevels` | `entry`, `junior`, `mid`, `senior`, `expert`. Jobs without a level are left out when this is set. |
| `skills` | Jobs tagged with a skill (`Python`, `Salesforce`, `Figma`), one search each. Wider than a keyword: it matches Jobgether's skill tags, not only the title. |
| `companies` | Only jobs at these employers, by name. |
| `minSalary` | Only jobs whose shown yearly salary starts at or above this amount, in the job's own currency. Jobs without a salary are left out. |
| `salaryCurrency` | Only jobs paid in this currency (`USD`, `EUR`, `GBP`, `CAD`). |
| `postedWithinDays` | Only jobs added in the last N days; reading stops once a page is older. |
| `sortBy` | `date` (default, newest first) or `relevance` (Jobgether's default order). |
| `includeDescription` | Opens each job page for the full description as text and the valid-through date: one extra request per job, about 0.9 s each (20 jobs took 17.5 s). |
| `includeRequirements` | One more request per job for qualifications and responsibilities as lists, industries, languages, soft skills and the complete skill list. Jobgether allows 30 such requests a minute, so this adds about 2 s per job. |
| `maxResults` | Stop after N jobs (default 50, 0 = no cap). With several searches the cap is shared evenly. Also accepted: `maxItems`, `maxJobs`. |
| `onlyNewSinceLastRun`, `stateName` | Remember delivered job ids in the `jobgether-jobs-state` key-value store of your account and skip them next time (not charged). |
| `skipJobIds` | Job ids you already have (not charged). |

```json
{
    "keywords": ["data engineer", "analytics engineer"],
    "locations": ["Europe"],
    "experienceLevels": ["senior"],
    "postedWithinDays": 3,
    "onlyNewSinceLastRun": true,
    "stateName": "data-europe",
    "maxResults": 0
}
```

Input is forgiving: a value the Actor does not understand (a misspelt employment type, a location Jobgether does not know) is left out and named in the run's status message; the run does not fail. If a filter cannot be understood at all, no search is run, so you are never charged for jobs outside your request.

### Output

One row per job. This one was read on 17 November 2026 with `includeDescription` and `includeRequirements` (description shortened here):

```json
{
    "id": "6afbf4e78acd9c1f9b1d225c",
    "url": "https://jobgether.com/offer/6afbf4e78acd9c1f9b1d225c-customer-experience-customer-success-technical-leader",
    "title": "Customer Experience Customer Success Technical Leader",
    "company": "Cisco",
    "companyUrl": "https://jobgether.com/remote-jobs/company-cisco",
    "companyWebsite": "http://www.cisco.com",
    "companySize": "XLarge",
    "companyLogo": "https://cdn-s3.jobgether.com/cisco/profile.webp",
    "locations": ["North America", "Canada"],
    "locationsText": "North America, Canada",
    "countries": ["Canada"],
    "regions": ["North America"],
    "states": [],
    "worldwide": false,
    "remoteType": "Full Remote",
    "employmentType": "Full time",
    "seniority": "Senior (5-10 years)",
    "salaryMin": 158100,
    "salaryMax": 200500,
    "salaryCurrency": "CAD",
    "salaryPeriod": "year",
    "salaryHidden": false,
    "skills": ["Splunk", "Cloud Computing", "Onboarding Strategies", "Enterprise Application Software", "Statistical Modeling", "Scripting", "Application Development", "Relational Databases", "Splunk Development", "Customer Centricity"],
    "roles": ["Customer Success Manager", "Customer Success Specialist", "Customer Success Lead", "Head of Customer Success"],
    "postedAt": "2026-11-17T06:32:07.281Z",
    "applyUrl": "https://cisco.wd5.myworkdayjobs.com/Cisco_Careers/job/Calgary-Alberta-Canada/Customer-Experience-Customer-Success-Technical-Leader_2030506",
    "easyApply": false,
    "description": "Job Description\nThis is a remote role and can be located anywhere in Western Canada.\nMeet the Team\nAs a Customer Success Platform Area TAM Leader (Splunk), you are deeply invested into customers ...",
    "expiresAt": "2027-01-17T06:32:07.281Z",
    "qualifications": ["5+ years experience administering and using Splunk Core (Enterprise/Cloud)", "3+ years Splunk architecture, data onboarding, and Splunk Core product feature experience", "3+ years SPL (Search Processing Language) skills", "Experience in technical consulting or big-data analytics", "Splunk Architect certification"],
    "responsibilities": ["Drive solutions to address customer requests and enhance their experience.", "Deliver workshops and prescriptive guidance for customer onboarding and enablement.", "Engage with Technical Success Engineers to assess account health and address risks.", "Lead internal projects to evolve business practices and frameworks."],
    "industries": ["Computer & Networking Hardware"],
    "languages": ["English"],
    "softSkills": ["Consulting", "Analytical Skills", "Communication", "Problem Solving", "Teamwork", "Adaptability"],
    "search": "\"customer success\"",
    "source": "jobgether",
    "scrapedAt": "2026-11-17T08:29:19.402Z"
}
```

| Field | Meaning | Filled (1,000 newest jobs, 17 Nov 2026) |
|---|---|---|
| `id`, `url`, `title` | Jobgether job id (24 characters, stable across runs), job page, title | 100% |
| `company`, `companyUrl`, `companyLogo` | Hiring company, its page on Jobgether, logo | 100% |
| `companyWebsite`, `companySize` | The company's own website; size band as Jobgether shows it (`Startup`, `Scaleup`, `SME`, `Large`, `XLarge`) | 96%, 74% |
| `locations`, `locationsText` | Every place the job is open to, as listed on the job card | 100% |
| `countries`, `regions`, `states`, `worldwide` | The same list sorted into countries, regions (`Europe`, `EMEA`, `Latin America`, `Anywhere`) and US states; `worldwide` is true when the job is open to anyone | countries 98%, states 51%, regions 17% |
| `remoteType` | Remote arrangement as shown (`Full Remote` on every job in our runs) | 100% |
| `employmentType` | `Full time`, `Part time`, `Fixed term`, `Freelance` or `Internships` | 100% |
| `seniority` | Experience level as shown, e.g. `Senior (5-10 years)` | 70% |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | The salary range Jobgether shows, per year. Null when no salary is shown; then `salaryHidden` is true. Never estimated by this Actor | 46% |
| `skills`, `roles` | Skills tagged on the job (five from the list, all of them with `includeRequirements`); job roles Jobgether files it under | 100%, 89% |
| `postedAt` | When the job was added to Jobgether (ISO 8601, UTC) | 100% |
| `applyUrl` | The employer's application page, without tracking parameters | 100% |
| `easyApply` | True when Jobgether offers its own quick-apply for the job | false on all 1,000 |
| `description`, `expiresAt` | Full description as text, without e-mail addresses and phone numbers, and the valid-through date (`includeDescription`) | 100% of 48 jobs older than three hours; see the FAQ for the newest jobs |
| `qualifications`, `responsibilities`, `industries`, `languages`, `softSkills` | Requirements as lists, the employer's industries, required languages (`includeRequirements`) | 100% of 35 jobs |
| `search`, `source`, `scrapedAt` | The search of the run that found the job, `jobgether`, read time | 100% |

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

**$0.80 per 1,000 jobs** plus $0.001 per run, on Apify's pay-per-event pricing (SILVER $0.68, GOLD and above $0.56 per 1,000). Descriptions and requirements cost nothing extra. Jobs left out by a filter, by only-new mode or by `skipJobIds` are never charged, and a run that finds nothing new costs $0.001.

| Run on 17 November 2026 | Jobs saved | Requests | Time | Cost |
|---|---|---|---|---|
| `{}` | 50 | 1 | 2-3 s | $0.041 |
| `keywords: ["data engineer"]`, `maxResults: 200` | 200 | 5 | 10 s | $0.161 |
| `python` in Germany, no cap | 128 | 4 | 7 s | $0.103 |
| All jobs, `maxResults: 1000` | 1,000 | 30 | 63 s | $0.801 |
| All jobs, no cap | 9,557 | 252 | 8 min 49 s | $7.647 |
| GitLab + ConcertoCare, no cap | 229 | 7 | 15 s | $0.184 |
| 20 jobs with `includeDescription` | 20 | 22 | 18 s | $0.017 |
| 20 jobs with description and requirements | 20 | 42 | 47 s | $0.017 |
| Second run of an only-new feed | 0 | 4 | 7 s | $0.001 |

Set a maximum cost per run in the run options and the Actor stops cleanly at that amount.

### Tips for a daily remote-jobs feed

- **Schedule a narrow search, not the whole board.** Jobgether serves the newest 500 jobs per search. A search by keyword, skill, country, company or employment type usually has fewer than 500 new jobs a day, so `onlyNewSinceLastRun` with `maxResults: 0` delivers every new one.
- **Run broad feeds more often.** New jobs arrive in batches about once an hour (the 1,000 newest jobs on 17 November 2026 spanned five hours). For all jobs of a large country, schedule the run every hour or two. A feed of the whole board is not complete at any schedule we tested: one uncapped run reached 2,350 jobs of the previous 24 hours.
- **Use `postedWithinDays: 1` or `2` on a feed.** Reading stops at the first page older than the window, so a run that finds little costs three or four requests.
- **One memory per feed:** give each schedule its own `stateName`.
- **Descriptions on a feed:** turn on `includeDescription` only on the scheduled only-new run; it then opens just the new jobs.
- **Country filters include wider jobs.** `locations: ["Germany"]` returns jobs open to Germany, to Europe or EMEA, and to anyone. Keep the rows whose `countries` contains `Germany` if you want only the jobs that name it.
- **Salary filters:** `minSalary` compares the lower end of the shown range in the job's own currency; add `salaryCurrency` so 150,000 means US dollars.

### How it reads Jobgether

The Actor reads the public JSON that Jobgether's own search page loads, 50 jobs per request, and the public job page for descriptions. It never logs in and never starts an application.

- **500 jobs per search.** Jobgether's search answers ten pages of 50. A search that lists more is read again per employment type and then per experience level, largest groups first, newest first in each, and merged without duplicates. A run capped at 1,000 jobs returned 1,000 distinct jobs in 30 requests, a run without a cap 9,557 in 252 requests, and a run with a 60-second timeout saved 744 and ended normally.
- **Pace.** Jobgether states a limit of 30 requests a minute for its search data. The Actor sends one such request every 2.1 seconds, waits and retries when the site asks it to slow down, and ends a run with what it has saved before the run's timeout.
- **Names, not ids.** Locations, companies and skills are looked up in Jobgether's own lists. A name that is not there is never guessed.

### FAQ

##### Is there a Jobgether API?

Yes, Jobgether has a public job-search API for AI assistants. When we called it on 17 November 2026 it returned at most 25 jobs per page and ten pages per search, with the title, company, location line, contract type, experience level, job functions, posting time and the Jobgether link. This Actor reads the data behind Jobgether's own search page instead, which carries more: 50 jobs per page, skills, the salary range as numbers, the company's website and size and the employer's apply link. It adds descriptions, requirements, an only-new feed, more than 500 jobs per search, and export to CSV, Excel, Google Sheets or a webhook through Apify.

##### How many remote jobs does Jobgether have?

Its search listed 173,013 jobs on 17 November 2026: 145,039 full time, 11,687 part time, 7,422 freelance, 6,428 fixed term and 2,553 internships; 2,500 for the keyword `data engineer`, 1,417 for `customer success`, 743 for `python`.

##### Can I get more than 500 jobs for one search?

Yes, up to a point. The Actor splits a large search by employment type and experience level. On 17 November 2026 a run over all jobs with no cap returned 9,557 distinct jobs in 252 requests and just under nine minutes, 2,350 of them posted in the previous 24 hours. It cannot list all 173,013 jobs in one run, and it does not reach every job of a day on the whole board. For full coverage of a niche, search by keyword, skill, country or company so that each search stays under 500 results.

##### Does every job have a salary?

No. Jobgether showed a salary range on 46% of the 1,000 newest jobs on 17 November 2026 (430 in USD, 18 in CAD, a few in GBP and EUR), and on 2% of the jobs open to Germany for `python`. Amounts are per year, as Jobgether shows them. When there is no salary the numbers are null and `salaryHidden` is true.

##### Where does the apply link go?

To the employer's own application page. In the 1,000 newest jobs on 17 November 2026 the most common hosts were Workday (276), Lever (266), Ashby (79) and Greenhouse (78). The link is given without Jobgether's tracking parameters.

##### Why do some jobs have no description?

Jobgether lists some very new jobs whose job page is not readable: on 17 November 2026, 4 of the 12 jobs under three hours old that we opened answered "gone", while all 48 older jobs had a description. Such a job is still saved with every list field and the apply link, and the status message says how many. Run with `postedWithinDays` and only-new mode a few hours behind the newest postings if every row must carry a description.

##### Does it return hybrid or on-site jobs?

Every job in our runs was marked `Full Remote`. The `remoteType` field carries what Jobgether shows.

##### Does it collect recruiter names or contact details?

No. A row is the job, the hiring company's public profile and the employer's apply link. Some employers write a mailbox, a phone number or a contact person into the job text (12 of the 98 descriptions we read on 17 November 2026 had a mailbox): the Actor replaces them with `[email removed]`, `[phone removed]` and `[name removed]`. A name inside a running sentence cannot be told apart from other words and stays.

##### What happens when Jobgether is slow or a filter has a typo?

Requests are retried with growing pauses. A page that still fails is reported in the status message while the jobs already saved are kept. An unknown filter value is left out and named in the status message; the run still succeeds.

##### Is it legal to scrape Jobgether?

The Actor reads job listings that Jobgether shows publicly, without logging in, at a low request rate. You are responsible for how you use the data.

Questions or a field you need? Use the **Issues** tab.

### Changelog

- **17 November 2026 (0.1).** First release: keyword, skill, location, company, employment-type, experience, salary and date filters; description and requirements on request; only-new feeds.

### Related Actors by Daemon Data

- [Career Site Jobs API](https://apify.com/data_daemon/career-site-jobs-scraper): jobs straight from company career sites on Workday, Greenhouse, Lever, Ashby and SmartRecruiters.
- [OnlineJobs.ph Scraper](https://apify.com/data_daemon/onlinejobs-ph-scraper): Philippine remote and virtual-assistant jobs with wages.
- [Get on Board Jobs Scraper](https://apify.com/data_daemon/getonbrd-jobs-scraper): Latin American tech jobs with salary and remote modality.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/data_daemon/welcome-to-the-jungle-jobs-scraper): the France-focused Welcome to the Jungle board, with a new-job feed.
- All Actors by [Daemon Data](https://apify.com/data_daemon).

# Actor input Schema

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

Job titles or words, one search each (e.g. `python`, `data engineer`, `customer success`). Uses Jobgether's own keyword search. Empty = all jobs, newest first.

## `locations` (type: `array`):

Where the candidate lives: a country (`Germany`, `United States`, `Brazil`), a region (`Europe`, `Latin America`, `APAC`), a US state (`Texas`) or `Worldwide`. One search per entry. Jobgether returns the jobs open to people there, including jobs open to the whole region or to anyone. Names are looked up in Jobgether's location list; unknown ones are skipped and named in the status message. Empty = everywhere.

## `employmentTypes` (type: `array`):

Only jobs of these employment types (Jobgether's contract filter). Empty = all.

## `experienceLevels` (type: `array`):

Only jobs of these seniority levels (Jobgether's experience filter). Jobs without a level are left out when this is set. Empty = all.

## `skills` (type: `array`):

Jobs tagged with a skill, one search each (e.g. `Python`, `Salesforce`, `Figma`). Wider than a keyword: it matches the skill tags Jobgether puts on each job, not only the title. Names are looked up in Jobgether's skill list.

## `companies` (type: `array`):

Only jobs at these employers (e.g. `GitLab`, `Automattic`). Names are looked up in Jobgether's company list; unknown ones are skipped and named in the status message.

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

Only jobs whose shown salary range starts at or above this yearly amount, in the job's own currency (e.g. `100000`). Jobs without a salary are left out when this is set.

## `salaryCurrency` (type: `string`):

Only jobs whose salary is shown in this currency, e.g. `USD`, `EUR`, `GBP`, `CAD`. Jobs without a salary are left out when this is set. Left-out jobs are not charged.

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

Only jobs added to Jobgether in the last N days. Reading stops once a page is older than the window.

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

Newest first (default) suits feeds and alerts. Relevance is the order Jobgether shows by default.

## `includeDescription` (type: `boolean`):

On: opens each job page (one extra request per job, about 0.6 seconds each) for the full description as text and the date the posting is valid through, at no extra charge. Off (default): the list fields only, 50 jobs per request.

## `includeRequirements` (type: `boolean`):

On: one more request per job for the qualifications and responsibilities as lists, the employer's industries, required languages, soft skills and the complete skill list, at no extra charge. Jobgether allows 30 such requests a minute, so this adds about 2 seconds per job. Off by default.

## `maxResults` (type: `integer`):

Stop after this many jobs in total. With several searches the cap is shared evenly between them. 0 = no cap (the run's maximum cost still applies).

## `onlyNewSinceLastRun` (type: `boolean`):

On: deliver only jobs that an earlier run with the same `stateName` (or the same search) has not delivered, and skip the rest without charging. Off (default): return every matching job.

## `stateName` (type: `string`):

Optional name for the only-new memory, e.g. `python-europe`. Runs with the same name share one memory. Empty = derived from the keywords, skills, locations, companies, employment types and experience levels.

## `skipJobIds` (type: `array`):

Jobgether job IDs you already have (the `id` field, 24 characters); they are skipped and not charged.

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

Optional, none by default. Jobgether answers Apify's datacenter addresses, so no proxy is needed.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "locations": [],
  "employmentTypes": [],
  "experienceLevels": [],
  "skills": [],
  "companies": [],
  "sortBy": "date",
  "includeDescription": false,
  "includeRequirements": false,
  "maxResults": 50,
  "onlyNewSinceLastRun": false,
  "skipJobIds": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

Jobs as JSON items in the default dataset (also downloadable as CSV, Excel, XML).

## `runSummary` (type: `string`):

RUN-SUMMARY record: each search with the number of jobs Jobgether lists, reached and saved; jobs skipped (already delivered / skipJobIds / filters); notes on input values that could not be used; charged counts.

# 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": [
        "python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_daemon/jobgether-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 = { "keywords": ["python"] }

# Run the Actor and wait for it to finish
run = client.actor("data_daemon/jobgether-jobs-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 '{
  "keywords": [
    "python"
  ]
}' |
apify call data_daemon/jobgether-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_daemon/jobgether-jobs-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/oQDt3G0SuaslWyJec/builds/eHU3WqP92o3Ffnb5E/openapi.json
