# Gupy Jobs Scraper | Brazil Jobs with Descriptions (Gupy Portal) (`data_daemon/gupy-jobs-scraper`) Actor

$0.80 per 1,000 jobs, description included | Scrape Gupy (portal.gupy.io), the job portal of Brazil's largest ATS: title, company, city, state, remote/hybrid/on-site, job type (CLT, estágio, PJ), PcD, deadline, full description. Keyword, state and city search, newest first, only-new mode. No login.

- **URL**: https://apify.com/data_daemon/gupy-jobs-scraper.md
- **Developed by:** [Daemon Data](https://apify.com/data_daemon) (community)
- **Categories:** Jobs, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 0.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

**Gupy Jobs Scraper** is a pay-per-result Apify Actor that returns job postings from the [Gupy job portal](https://portal.gupy.io/) (portal.gupy.io), the public job board of Gupy, the applicant-tracking system used by thousands of Brazilian employers (Itaú, Stefanini, Logicalis, Sesc, Globalhitss and many more), as JSON, CSV or Excel. It is for job aggregators and job boards, recruiters and staffing agencies, HR-tech and career-platform builders, labour-market analysts and job-alert services in Brazil. Each row has the title, company and its Gupy career site, city and state, workplace type (on-site, hybrid, remote), vacancy type (CLT, internship, apprentice, temporary, PJ), the PcD flag, publication date, application deadline and the **full description**. Price: **$0.80 per 1,000 jobs**, plus $0.001 per run. You need no login, cookies, proxy or browser. In the 24 hours to 29 October 2026, employers published about **2,700 jobs** on the portal, and the portal listed the newest **10,000 jobs** (back to 23 October).

**$0.0008 per job, description included**, plus $0.001 per run. The Actor reads the JSON page data that portal.gupy.io's own search page loads (Gupy's robots.txt allows the whole portal), so runs are fast: 50 jobs take a few seconds. Apify's free plan ($5 credit every month) covers more than **6,000 jobs**. It is built for schedules. Switch on **Only new jobs since the last run** and a daily run returns, and charges for, only the jobs you have not received before.

> Live check, 30 Oct 2026: the default run (the 50 newest jobs with descriptions) took **3.5 seconds** on the Apify platform and cost $0.04 plus the $0.001 start fee. A full pull of **every job the portal listed (9,879 jobs from 1,571 employers, published 26–29 October)** took 308 seconds: 91.8% on-site, 6.7% hybrid, 1.5% remote; 85.4% regular CLT jobs, 3.7% apprenticeships, 3.5% temporary, 3.0% internships, 1.2% PJ; 76% marked open to people with disabilities (PcD; an earlier 240-job sample was misread as 30%); 42% in São Paulo state; every job had a description and deadline, 98% a city and state. Results come newest first. The full numbers, by state, city, employer and role, are in [Brazil job postings on Gupy: what 9,879 new jobs in October 2026 show](https://dev.to/datadaemon/brazil-job-postings-on-gupy-what-9879-new-jobs-in-october-2026-show-remote-share-pcd-clt-vs-4bjj).

### Who uses Gupy job data, and what for

| You are | What this Actor gives you |
|---|---|
| **Job aggregators and job boards** | Every new posting on Brazil's largest ATS portal as a daily feed (about 2,700 a day), with stable ids, full description text, location, workplace and vacancy type, de-duplicated across keywords and runs. Same conventions as the Welcome to the Jungle, Foundit, Apna and Shine Actors by the same publisher. |
| **Recruiters and staffing agencies** | Who is hiring for which roles, where and on which terms (CLT, PJ, estágio), refreshed daily, with the application deadline. |
| **HR-tech and career-platform builders** | A clean, structured job feed to show in your app, match against candidate profiles or power job alerts. |
| **Labour-market analysts and employer-branding teams** | Postings per company, state, city and workplace type; the share of remote and hybrid roles; PcD-inclusive vacancies. |
| **Job-alert services and communities** | A daily list of new postings for a keyword and a state, delivered to Google Sheets, Slack, Telegram or a webhook. |
| **AI agents (MCP)** | Ask Claude or ChatGPT "remote data analyst jobs on Gupy posted this week in São Paulo" and let it call this Actor through Apify's MCP server. |

### How to scrape Gupy jobs (about a minute)

1. Click **Try for free**. The form is pre-filled with the 50 newest jobs on the portal.
2. Optionally add keywords (`analista de dados`, `enfermeiro`, `python`), states (`São Paulo`, `Minas Gerais`) or cities (`Curitiba`), and filters such as **Remote**, **Internship** or **Posted within the last 7 days**.
3. Click **Start**. 50 jobs take a few seconds and cost **$0.04**.
4. Download the results as JSON, CSV or Excel. Or save the input as a task, tick **Only new jobs since the last run** and **schedule it daily** to get a fresh feed in Google Sheets, a webhook, Make, Zapier or n8n.

**From code** (returns the jobs in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~gupy-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["analista de dados"], "states": ["São Paulo"], "postedWithinDays": 7, "maxResultsPerSearch": 100}'
```

**From an AI assistant:** add the MCP connector `https://mcp.apify.com/?tools=data_daemon/gupy-jobs-scraper` in Claude, ChatGPT, Cursor or VS Code.

### Export every new Gupy job (full-board daily feed)

Leave the keywords empty and set `maxResultsPerSearch` to `0`: the Actor walks the portal newest first until it reaches jobs older than `postedWithinDays`. Employers published about 2,700 jobs in the 24 hours to 29 October 2026 (12 jobs per page, so a day is about 230 requests and takes a few minutes). With only-new mode the run delivers each job once even when it is refreshed or found by a second search.

```json
{
    "postedWithinDays": 1,
    "maxResultsPerSearch": 0,
    "onlyNewSinceLastRun": true,
    "stateName": "gupy-full-feed-daily"
}
```

That is about **$2.20 a day, or $65 a month**, for every job posted on the portal. Add `states` to split the feed by state, or `workplaceTypes: ["remote", "hybrid"]` for a remote-only feed (about 4% of postings, checked on each job after download, so the run still reads every page of the day).

### Gupy jobs by keyword, state or city

`searchTerms`, `states` and `cities` are applied by Gupy before anything is downloaded, so a keyword × state search stays small and cheap. On 30 Oct 2026, `analista de dados` in São Paulo returned 11 jobs posted in the last 3 days; `vendedor` in Curitiba returned 12 on the first page. Keywords are matched against titles and descriptions, in Portuguese or English as the employer wrote them.

```json
{
    "searchTerms": ["analista de dados", "engenheiro de dados"],
    "states": ["São Paulo", "Rio de Janeiro"],
    "postedWithinDays": 7,
    "maxResultsPerSearch": 0,
    "onlyNewSinceLastRun": true,
    "stateName": "dados-sp-rj-weekly"
}
```

### Gupy API: input

Every field is optional. An empty input returns the 50 newest jobs on the portal.

| Field | What it does |
|---|---|
| `searchTerms` | Keywords matched by Gupy against titles and descriptions, e.g. `analista de dados`, `python`, `vendedor`. Each keyword is one search (combined with every state and city). Empty = every job, newest first. |
| `states` | Brazilian states as Gupy spells them, e.g. `São Paulo`, `Minas Gerais`, `Paraná`. Each is its own search. |
| `cities` | City names, e.g. `São Paulo`, `Curitiba`, `Belo Horizonte`. Each is its own search. |
| `workplaceTypes` | `remote`, `hybrid`, `on-site` (checked on each job). |
| `jobTypes` | `effective` (regular CLT job), `internship`, `apprentice`, `temporary`, `legal_entity` (PJ), `freelancer`, `autonomous`, `lecturer`, `associate`, `talent_pool`, `volunteer` (checked on each job). Portuguese names such as `estágio`, `aprendiz`, `PJ` are accepted. |
| `pwdOnly` | Only jobs marked open to people with disabilities (PcD). |
| `postedWithinDays` | Only jobs published in the last N days, e.g. `1` for a daily feed. The search stops at the first page of older jobs. |
| `locations` | City or state words checked on each job (accent-insensitive), e.g. `Campinas`; `remote` matches remote jobs. Use it to combine one keyword with several places in one search. |
| `includeDescription` | Full description as plain text (default on; it costs the same either way). |
| `maxResultsPerSearch` | Cap per keyword × place search (default 50, newest first). `0` = no cap. |
| `maxResults` | Total cap for the run. |
| `onlyNewSinceLastRun`, `stateName` | Only-new mode for schedules (see below). |
| `skipIds` | Job ids you already have; neither saved nor charged. |

Common names from other scrapers (`keywords`, `query`, `state`, `city`, `jobType`, `remote`, `location`, `maxItems`, `onlyNew` and more) are accepted as aliases.

### Output: Gupy job data fields

One item per job:

```json
{
  "id": 12774503,
  "title": "22463-Arquiteto Devops",
  "url": "https://globalhitss.gupy.io/job/eyJqb2JJZCI6MTI3NzQ1MDMsInNvdXJjZSI6Imd1cHlfcG9ydGFsIn0=?jobBoardSource=gupy_portal",
  "company": "Hitss Brasil",
  "companyUrl": "https://globalhitss.gupy.io/",
  "companyLogo": "https://attachments.gupy.io/production/companies/57061/career/142570/images/2025-01-23_13-49_companyLogoUrl.png",
  "careerPage": "globalhitss",
  "jobType": "effective",
  "jobTypeRaw": "vacancy_type_effective",
  "workplaceType": "remote",
  "isRemote": true,
  "city": null,
  "state": null,
  "locationText": "Remote",
  "acceptsPwd": true,
  "postedAt": "2026-10-29T15:15:11.655Z",
  "applicationDeadline": "2026-12-22T00:00:00.000Z",
  "description": "Na Hitss, a inovação é o nosso combustível, a curiosidade é o nosso motor e o respeito pelo cliente é o nosso guia. ...",
  "searchTerm": null,
  "scrapedAt": "2026-10-29T15:51:20.684Z"
}
```

You can download the dataset as JSON, CSV, Excel, XML or HTML, or read it through the Apify API. The Output tab has two views: **Overview** and **With descriptions**.

#### Data fields

| Field | Description |
|---|---|
| `id`, `url` | Gupy job id (stable) and the job page on the company's Gupy career site |
| `title`, `company`, `companyUrl`, `companyLogo`, `careerPage` | Role and employer; `careerPage` is the career-site slug (the subdomain of the job URL) |
| `jobType`, `jobTypeRaw` | Vacancy type: effective (CLT), internship, apprentice, temporary, legal_entity (PJ), freelancer, autonomous, lecturer, associate, talent_pool, volunteer; and Gupy's raw value |
| `workplaceType`, `isRemote` | on-site, hybrid or remote |
| `city`, `state`, `locationText` | Place set by the employer (99% of jobs on 30 Oct 2026); `Remote` when a remote job has none |
| `acceptsPwd` | The employer marked the job as open to people with disabilities (PcD) |
| `postedAt`, `applicationDeadline` | Published and last day to apply (ISO 8601, UTC) |
| `description` | Full description as plain text, as the employer wrote it (Portuguese or English) |
| `searchTerm`, `scrapedAt` | Keyword that found it; when this run saved it |

Salary is not shown on the Gupy portal, so there is no salary field. Recruiter names and contact details are not collected.

### Export Gupy jobs to Google Sheets, CSV, Excel or a webhook

1. Paste an input from above, click **Save as task**, then **Schedules → Create schedule → Daily** (for example `0 9 * * *`, 09:00 in Brasília is `0 12 * * *` UTC) and add the task.
2. The first run delivers every matching job. Every later run delivers only jobs that were not delivered before, and **skipped jobs are not charged**. The memory is a key-value store named `gupy-jobs-state` in your own Apify account, with one record per `stateName`. It forgets ids after 180 days.
3. Give each saved search its own `stateName`, or leave it empty and the Actor derives one from the keywords, places and filters. To start over, change the name.
4. Every run writes a `RUN-SUMMARY` record to its key-value store with keywords, places, found, saved, filtered, skipped and charged counts. A webhook consumer can decide what to do without opening the dataset.

**Where the results go**

- **CSV or Excel download**: the run's Output tab, or `https://api.apify.com/v2/datasets/<datasetId>/items?format=csv` for a direct file link.
- **Google Sheets**: the task's Integrations tab has an Apify Google Sheets integration that appends every run's rows to a sheet.
- **Slack, email, webhook**: a message per run, or a **webhook** to your backend when the run finishes.
- **Make, Zapier, n8n**: use the Apify module/node with the task id, or call the synchronous endpoint above.

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

Pay per event. Platform compute is included, and the Actor runs in 512 MB, so the start fee is always a single event.

| Event | Price | When it is charged |
|---|---|---|
| Job | $0.0008 | Each job saved to your dataset, description included |
| Actor start | $0.001 | Once per run |

That is **$0.80 per 1,000 jobs**. Jobs skipped by only-new mode, `skipIds`, de-duplication or your workplace, job-type, location and date filters are never charged. Scale plans pay 15% less and Business plans 30% less.

| How teams use it | Volume (measured 30 Oct 2026) | Cost |
|---|---|---|
| Quick look: 50 newest jobs (3.5 seconds on 30 Oct 2026) | 50 jobs, 1 run | $0.041 |
| Keyword × state, last 7 days, weekly (`analista de dados`, São Paulo: 11 jobs in 3 days) | about 25 jobs a week | about $0.09 a month |
| Daily feed of every new job on the portal | about 2,700 jobs a day | about $2.20 a day, $65 a month |
| Daily remote + hybrid feed (about 4% of postings) | about 110 jobs a day | about $0.12 a day, $3.60 a month |

Apify's free plan includes $5 of usage a month: more than 6,000 jobs, enough for two days of the full feed or months of keyword feeds.

### Tips

- `searchTerms`, `states` and `cities` are applied by Gupy and make runs smaller. `workplaceTypes`, `jobTypes`, `pwdOnly`, `locations` and `postedWithinDays` are checked on each job after download: a rare combination (remote internships, for example) reads many pages before it finds enough matches, so pair it with a keyword or a state, or set a **maximum cost per run** and a `maxResults`.
- The portal lists the newest 10,000 jobs (about six days of postings on 30 Oct 2026; nothing older is reachable). For history, run a daily only-new feed and keep the datasets.
- Keywords are matched by Gupy against titles and descriptions, so `python` finds jobs that mention Python anywhere in the text. For title-only matching, filter on `title` yourself.
- Set a **maximum cost per run** on the task. The Actor stops cleanly at the limit and says so in the status message.

### FAQ

**Is there an official Gupy jobs API?**

Gupy offers no public job-search API. This Actor reads the JSON page data that portal.gupy.io's own search page loads (robots.txt allows the whole portal), and exposes it as a REST API with schedules, webhooks and only-new runs, so you do not maintain a scraper or proxies yourself.

**How much does it cost to scrape Gupy?**

$0.0008 per job with its description plus $0.001 per run, so 50 jobs cost about $0.04, every job posted on the portal in a day about $2.20, and a weekly keyword × state feed a few cents a month.

**Is it legal to scrape Gupy?**

The Actor only reads job postings that Gupy shows to anyone without a login, through pages its robots.txt allows, and it collects no data about candidates or recruiters. Public job-posting data is generally collected for aggregation, research and recruiting; you remain responsible for complying with Gupy's terms of use and the law that applies to you (including the LGPD, which this Actor's output, company job postings, does not concern).

**Can I get every job posted on Gupy today?**

Yes: leave the keywords empty, set `postedWithinDays: 1` and `maxResultsPerSearch: 0`. That was about 2,700 jobs (about $2.20) on 29 Oct 2026. Switch on only-new mode so a daily schedule delivers each job once.

**Does it return the salary?**

No. The Gupy portal does not show salaries; the description sometimes mentions one.

**Can I filter by remote jobs or by internships?**

Yes, with `workplaceTypes: ["remote"]` and `jobTypes: ["internship"]`. Both are checked on each job after download (the portal's search cannot filter them), so combine them with a keyword or a state to keep the run short. Of the 9,879 jobs the portal listed on 29 Oct 2026, 1.5% were remote, 6.7% hybrid and 3.0% internships.

**How many jobs are posted on Gupy per day, and what do they look like?**

About 2,700 on a weekday in late October 2026 (2,692 on Tuesday 27 and 2,793 on Wednesday 28 October). Shares by workplace type, vacancy type, PcD flag, state, city, employer and role, with the analysis code, are in the study [Brazil job postings on Gupy: what 9,879 new jobs in October 2026 show](https://dev.to/datadaemon/brazil-job-postings-on-gupy-what-9879-new-jobs-in-october-2026-show-remote-share-pcd-clt-vs-4bjj) (FAQ in English and Portuguese).

**Can I export Gupy jobs to Excel or Google Sheets?**

Yes. Every run's dataset downloads as CSV, Excel, JSON, XML or HTML, and the task's Integrations tab appends rows to a Google Sheet after each run.

**Does it include candidate or recruiter details?**

No. It returns job postings only: the employer, the role, where and on which terms, the deadline and the description.

**Do I need a proxy or login?**

No.

### Related Actors by Daemon Data

- [Welcome to the Jungle Jobs Scraper](https://apify.com/data_daemon/welcome-to-the-jungle-jobs-scraper) – French and European jobs with full descriptions, skills and tools; only-new mode
- [Foundit Jobs Scraper](https://apify.com/data_daemon/foundit-jobs-scraper) – foundit.in (Monster India) jobs with full descriptions, full-board daily feed
- [Apna Jobs Scraper](https://apify.com/data_daemon/apna-jobs-scraper) – Apna (apna.co) India jobs with salary, locality and department: entry-level and frontline jobs, full-board export
- [Shine Jobs Scraper](https://apify.com/data_daemon/shine-jobs-scraper) – Shine.com India jobs with full descriptions, salary range, experience, skills and industry
- [Instahyre Jobs Scraper](https://apify.com/data_daemon/instahyre-jobs-scraper) – India tech and startup jobs with company size and full descriptions
- [Unstop Scraper](https://apify.com/data_daemon/unstop-scraper) – Unstop jobs, internships, hackathons and competitions with stipends, prizes and deadlines

All Daemon Data Actors: [apify.com/data_daemon](https://apify.com/data_daemon).

### Support

Found a bug or need another field or filter? Open an issue on the Issues tab; issues are usually answered within a day. Custom variants of this Actor are available on request.

A quick review on the Actor page helps other users find it.

### Disclaimer

This Actor collects publicly available job postings for informational purposes and does not collect personal data about candidates or recruiters. Respect the source website's terms of use and applicable data-protection laws when using the data.

# Actor input Schema

## `searchTerms` (type: `array`):

Optional. Gupy matches them against job titles and descriptions, e.g. `analista de dados`, `python`, `vendedor`, `enfermeiro`. Each keyword is one search. Leave empty to get every job on the portal, newest first (about 2,700 new jobs a day in late October 2026).

## `states` (type: `array`):

Brazilian states, e.g. `São Paulo`, `Minas Gerais`, `Rio de Janeiro`, `Paraná`. Accent-less names (`Sao Paulo`) and two-letter codes (`SP`, `MG`, `RJ`) work too and are mapped to Gupy's spelling. Each state is one search (combined with every keyword). Applied by Gupy before anything is downloaded.

## `cities` (type: `array`):

City names, e.g. `São Paulo`, `Curitiba`, `Belo Horizonte`. Each city is one search (combined with every keyword). Applied by Gupy before anything is downloaded.

## `workplaceTypes` (type: `array`):

Only jobs with these workplace types (checked on each job; on 30 Oct 2026 about 96% of the newest jobs were on-site). Empty = any.

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

Only these Gupy vacancy types (checked on each job). Empty = any. `effective` is a regular (CLT) job; `legal_entity` is a PJ contract.

## `pwdOnly` (type: `boolean`):

Only jobs the employer marked as open to people with disabilities (`acceptsPwd`).

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

Only jobs published on Gupy in the last N days (e.g. 1 for a daily feed, 7 for weekly). Jobs come newest first, so the search stops at the first page of older jobs. 0 or empty = any date.

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

Only jobs whose city or state contains one of these words (accent-insensitive), e.g. `Campinas`, `Paraná`. `remote` matches remote jobs. Unlike `states` and `cities`, this is checked after download; use it to combine a keyword search with several places in one run.

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

Full job description as plain text (`description`). It costs the same either way; turn it off for smaller files.

## `maxResultsPerSearch` (type: `integer`):

Cap for each keyword × place search. Newest jobs come first. 0 = no cap (the portal lists its newest 10,000 jobs, about six days of postings on 30 Oct 2026).

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

Stop after this many saved jobs. 0 or empty = no total cap (the run's maximum cost still applies).

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

For schedules: remember delivered job ids (in a named key-value store in your account) and save only jobs that earlier runs with the same settings did not deliver. Skipped jobs are not charged.

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

Name of the only-new memory. Empty = derived from the keywords, places and filters. Give two schedules the same name to share one memory.

## `skipIds` (type: `array`):

Gupy job ids you already have (the `id` field). They are neither saved nor charged.

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

Not needed: the Gupy portal answers Apify servers directly. Use a proxy only if requests start failing.

## Actor input object example

```json
{
  "searchTerms": [],
  "states": [],
  "cities": [],
  "workplaceTypes": [],
  "jobTypes": [],
  "pwdOnly": false,
  "locations": [],
  "includeDescription": true,
  "maxResultsPerSearch": 50,
  "onlyNewSinceLastRun": false,
  "skipIds": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

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

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

RUN-SUMMARY record: keywords, places, jobs found, saved, filtered, skipped (already delivered / skipIds) and 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 = {};

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

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

```

## MCP server setup

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